diff --git a/api/agent.yaml b/api/agent.yaml index fb78148..714b8f6 100644 --- a/api/agent.yaml +++ b/api/agent.yaml @@ -45,13 +45,13 @@ paths: schema: $ref: "#/components/schemas/VPC" "400": - description: Missing required field or invalid request body + description: Missing required field, invalid request body, or l3vni out of range content: application/json: schema: $ref: "#/components/schemas/Error" "409": - description: VPC already exists + description: VPC already exists, l3vni already used by another VPC, or l3vni requested on an agent without a bgp section content: application/json: schema: @@ -281,7 +281,7 @@ paths: "404": $ref: "#/components/responses/NotFound" "409": - description: Subnet not deletable — only running or error states can be deleted + description: Subnet not deletable — only running or error states can be deleted, and no VM that is not deleted may still have an interface on it content: application/json: schema: @@ -317,6 +317,17 @@ components: type: string description: CIDR block for the entire VPC address space example: "10.0.0.0/16" + l3vni: + type: integer + format: int32 + minimum: 1 + maximum: 65535 + description: >- + Optional. L3VNI of the VPC, used for inter-subnet routing between hypervisors + (symmetric IRB). Also the id of the routing table of the VPC VRF, so 253-255 are + rejected, and the number of the route distinguisher :, which holds 16 bits. Requires the bgp section in the agent configuration, and must not be used + by another VPC of the agent. Absent: the VPC has no L3VNI. + example: 4001 VPC: type: object @@ -331,6 +342,10 @@ components: cidr: type: string example: "10.0.0.0/16" + l3vni: + type: integer + description: L3VNI of the VPC, absent when the VPC has none + example: 4001 SubnetCreateRequest: type: object diff --git a/cmd/agent/main.go b/cmd/agent/main.go index b7ecc32..197d1c3 100644 --- a/cmd/agent/main.go +++ b/cmd/agent/main.go @@ -13,7 +13,9 @@ import ( agentapi "git.g3e.fr/syonad/two/internal/api/agent" configuration "git.g3e.fr/syonad/two/internal/config/agent" dispatcher "git.g3e.fr/syonad/two/internal/dispatcher/agent" + "git.g3e.fr/syonad/two/internal/frr" "git.g3e.fr/syonad/two/internal/migration" + "git.g3e.fr/syonad/two/internal/netif" agentmetrics "git.g3e.fr/syonad/two/internal/prometheus/agent" "git.g3e.fr/syonad/two/internal/watchdog" "git.g3e.fr/syonad/two/internal/watchdog/notify" @@ -29,11 +31,14 @@ const shutdownTimeout = 20 * time.Second func main() { confFile := flag.String("config", "/etc/two/agent.yml", "config file path") flag.Parse() + os.Exit(run(*confFile)) +} - cfg, err := configuration.LoadConfig(*confFile) +func run(confFile string) int { + cfg, err := configuration.LoadConfig(confFile) if err != nil { slog.Error("failed to load config", "error", err) - return + return 1 } log := logger.New(cfg.Logger.Level, cfg.Logger.Debug) @@ -50,12 +55,20 @@ func main() { // d'états, et des ressources transitoires orphelines d'un arrêt précédent. if err := migration.MigrateStates(db, log.With(slog.String("component", "migration"))); err != nil { log.Error("failed to migrate states", "error", err) - return + return 1 } if err := migration.MigrateVMNICs(db, log.With(slog.String("component", "migration"))); err != nil { log.Error("vm nic migration failed", "error", err) - return + return 1 + } + + if cfg.BGP.Enabled() { + if err := applyBGPBase(cfg, frr.NewClient()); err != nil { + log.Error("failed to apply the bgp base configuration", "error", err) + return 1 + } + log.Info("bgp base configuration applied", "asn", cfg.BGP.ASN, "route_reflectors", cfg.BGP.RouteReflectors) } q := worker.New(cfg.Worker.BufferSize) @@ -108,6 +121,23 @@ func main() { servers["admin"] = adminSrv } closeDB = shutdown(log, q, servers, shutdownTimeout) + return 0 +} + +type baseApplier interface { + ApplyBase(frr.Base) error +} + +func applyBGPBase(cfg *configuration.Config, frrClient baseApplier) error { + reflectors, err := cfg.BGP.Reflectors() + if err != nil { + return err + } + vtep, err := netif.VTEPAddress(cfg.DefaultInterface) + if err != nil { + return err + } + return frrClient.ApplyBase(frr.Base{ASN: cfg.BGP.ASN, RouterID: vtep, RouteReflectors: reflectors}) } type httpShutdowner interface { diff --git a/cmd/agent/main_test.go b/cmd/agent/main_test.go index 12291c7..9f3209c 100644 --- a/cmd/agent/main_test.go +++ b/cmd/agent/main_test.go @@ -5,11 +5,15 @@ import ( "errors" "io" "log/slog" + "os" + "path/filepath" "strings" "sync/atomic" "testing" "time" + configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/frr" "git.g3e.fr/syonad/two/pkg/worker" ) @@ -96,3 +100,46 @@ func TestShutdown_SansServeur(t *testing.T) { t.Fatal("l'absence de serveur ne doit pas empêcher un arrêt propre") } } + +type fakeBase struct{ called bool } + +func (f *fakeBase) ApplyBase(frr.Base) error { + f.called = true + return nil +} + +func TestApplyBGPBase_RefusesAnInvalidSectionBeforeTouchingFRR(t *testing.T) { + cfg := &configuration.Config{} + cfg.BGP.RouteReflectors = []string{"10.255.255.1"} + f := &fakeBase{} + if err := applyBGPBase(cfg, f); err == nil || !strings.Contains(err.Error(), "bgp.asn must be set") { + t.Errorf("erreur %v", err) + } + if f.called { + t.Error("ApplyBase appelé avec une section bgp invalide") + } +} + +func TestRunExitsNonZeroWhenTheConfigCannotBeLoaded(t *testing.T) { + conf := filepath.Join(t.TempDir(), "agent.yml") + if err := os.WriteFile(conf, []byte("bgp: [non: valide\n"), 0o600); err != nil { + t.Fatal(err) + } + if code := run(conf); code != 1 { + t.Errorf("code de sortie %d, 1 attendu", code) + } +} + +func TestRunExitsNonZeroWhenTheBGPBaseCannotBeApplied(t *testing.T) { + dir := t.TempDir() + conf := filepath.Join(dir, "agent.yml") + yml := "database:\n path: " + filepath.Join(dir, "db") + "\n" + + "default_interface: two-test-absent0\n" + + "bgp:\n asn: 64600\n route_reflectors: [10.255.255.1]\n" + if err := os.WriteFile(conf, []byte(yml), 0o600); err != nil { + t.Fatal(err) + } + if code := run(conf); code != 1 { + t.Errorf("code de sortie %d, 1 attendu", code) + } +} diff --git a/cmd/lab/main_test.go b/cmd/lab/main_test.go index 733fd3c..4b4ac5e 100644 --- a/cmd/lab/main_test.go +++ b/cmd/lab/main_test.go @@ -312,18 +312,20 @@ func TestRun_RenderShipsTheExampleFRRConfigs(t *testing.T) { if code != 0 { t.Fatalf("code %d, stderr %s", code, stderr) } - for node, want := range map[string]string{ - "sw1": "router bgp 65100", - "rr1": "bgp listen range 192.168.14.0/24 peer-group fabric", - "hv1": "bgp router-id 192.168.14.11", - "hv2": "bgp router-id 192.168.14.12", + for node, wants := range map[string][]string{ + "sw1": {"router bgp 65100"}, + "rr1": {"bgp listen range 192.168.14.0/24 peer-group fabric"}, + "hv1": {"hostname hv1", "route_reflectors: [10.255.255.1]"}, + "hv2": {"hostname hv2", "route_reflectors: [10.255.255.1]"}, } { data, err := os.ReadFile(filepath.Join(out, node, "user-data")) if err != nil { t.Fatal(err) } - if !strings.Contains(string(data), want) { - t.Errorf("%s user-data does not carry %q", node, want) + for _, want := range wants { + if !strings.Contains(string(data), want) { + t.Errorf("%s user-data does not carry %q", node, want) + } } } } diff --git a/conf/agent/config.exemple.yml b/conf/agent/config.exemple.yml index de0f6ae..a31a58d 100644 --- a/conf/agent/config.exemple.yml +++ b/conf/agent/config.exemple.yml @@ -35,6 +35,15 @@ interfaces: internet: br-000000 admin: br-000000 +# BGP control plane of the hypervisor (optional). +# Absent: the agent leaves FRR alone. Present: at every start, before serving its +# API, the agent applies the base BGP configuration through vtysh (router-id = the +# primary IPv4 of default_interface) and saves it with "write memory". +# Changing the asn requires removing the previous instance by hand. +# bgp: +# asn: 64600 +# route_reflectors: [10.255.255.1] + # Metadata server runtime directory (cloud-init files per VM) metadata: run_dir: "/run/two/metadata" diff --git a/docs/architecture/stockage.rst b/docs/architecture/stockage.rst index fd404a2..6da14d4 100644 --- a/docs/architecture/stockage.rst +++ b/docs/architecture/stockage.rst @@ -8,6 +8,7 @@ de sérialisation structurée. vpc//state → creating | running | error | deleting | deleted vpc//cidr → + vpc//l3vni → (optionnel : VPC routé par L3VNI) subnet//state → creating | running | error | deleting | deleted subnet//vpc → @@ -21,9 +22,10 @@ de sérialisation structurée. subnet//dhcp/ → vm//state → creating | running | error | deleting | deleted - vm//subnet → - vm//tap_id → - vm//ip → + vm//nic//subnet → (une interface par index, ordre du tableau interfaces) + vm//nic//ip → + vm//nic//primary → "true" (exactement une interface ; absent sur les autres) + vm//nic//tap_id → (alloué au premier démarrage, puis conservé) vm//metadata_port → vm//disk/ → (une clé par disque : sda, vda, …) vm//memory → (Mo) @@ -36,9 +38,14 @@ de sérialisation structurée. Règles ------ -**Pas de duplication.** Une ressource ne stocke que ce qui lui est propre. Une VM garde le lien -``vm//subnet`` ; le VPC, le bridge et l'``interface_ip`` sont lus depuis le subnet, leur -source canonique. +**Pas de duplication.** Une ressource ne stocke que ce qui lui est propre. Une interface de VM +garde le lien ``vm//nic//subnet`` ; le VPC, le mode, le bridge et l'``interface_ip`` sont +lus depuis le subnet, leur source canonique. De même, la L3VNI d'un VPC n'est stockée que sous +``vpc//l3vni`` : RT, RD, MAC de routeur et table de routage en sont calculés. + +**Ancien schéma des VM.** Avant le multi-interfaces, une VM portait directement ``subnet``, ``ip`` +et ``tap_id``. L'agent les migre au démarrage vers ``nic/0/…``, marquée ``primary``, avant +d'ouvrir son API ; une VM qui a déjà des clés ``nic/`` est laissée telle quelle. **Les états passent par ``state``.** Toujours ``state.Set`` / ``state.Get`` : ``Set`` refuse une valeur hors énumération, ``Get`` refuse de retourner une valeur non reconnue. ``error`` n'est diff --git a/docs/architecture/vue-densemble.rst b/docs/architecture/vue-densemble.rst index a0f5c3f..e589562 100644 --- a/docs/architecture/vue-densemble.rst +++ b/docs/architecture/vue-densemble.rst @@ -39,6 +39,13 @@ Paquets - migrations idempotentes jouées au démarrage de l'agent * - ``internal/vpc``, ``internal/subnet`` - création et suppression bas niveau (netns + netif) + * - ``internal/l3vni`` + - routage d'une VPC par L3VNI : VRF, L3VNI, transit, configuration FRR, export des routes + ``/24`` et ``/32`` + * - ``internal/frr`` + - génération des commandes FRR, seul point d'appel à ``vtysh`` + * - ``internal/sysctl`` + - écriture sous ``/proc/sys``, dans un netns si besoin * - ``internal/netns`` - network namespaces : create/enter/delete/call * - ``internal/netif`` diff --git a/docs/concepts/modes-reseau.rst b/docs/concepts/modes-reseau.rst index 270cb17..6204e2c 100644 --- a/docs/concepts/modes-reseau.rst +++ b/docs/concepts/modes-reseau.rst @@ -42,6 +42,17 @@ vxlan Le subnet vit dans le netns du VPC. La VM n'est donc **pas joignable depuis l'host** sans route explicite — point à connaître avant de câbler un outil externe dessus. +Le bridge du subnet, qui porte ``interface_ip``, a une **MAC de gateway propre à l'hôte**, calculée +depuis son VTEP — l'IPv4 primaire du ``local_iface`` : ``02:03`` suivi des quatre octets de +l'adresse (VTEP ``192.168.14.12`` → ``02:03:c0:a8:0e:0c``). Unique dans le fabric, elle est la +même pour tous les subnets d'un hôte, chacun étant un domaine L2 distinct. Elle n'est posée qu'à la +création du subnet — un subnet créé avant garde la MAC choisie par le noyau jusqu'à sa recréation. + +Une MAC de gateway **identique sur tous les hôtes** (anycast) a été essayée puis retirée : apprise +sur le veth du subnet, elle était annoncée en EVPN par chaque hôte et détectée en double ; et une +gateway ne pouvait plus joindre en L2 une VM d'un autre hôte, la réponse revenant à la gateway +locale de la VM. Le cache ARP d'une VM migrée à chaud est un sujet de la migration, pas du subnet. + bridge ------ diff --git a/docs/concepts/vpc-subnet-vm.rst b/docs/concepts/vpc-subnet-vm.rst index 6337ea9..8269149 100644 --- a/docs/concepts/vpc-subnet-vm.rst +++ b/docs/concepts/vpc-subnet-vm.rst @@ -20,6 +20,40 @@ d'isolation : deux VPC ne se voient pas, et peuvent réutiliser les mêmes plage Un VPC ne peut être supprimé que si tous ses subnets le sont déjà — sinon 409. +Routage entre hyperviseurs : ``l3vni`` +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Un VPC créé avec ``l3vni`` route ses subnets entre hyperviseurs par un **VNI de transit** propre +au VPC (IRB symétrique, `#41 `_) : un hyperviseur n'a +plus besoin de porter un subnet pour joindre ses VM. Sans ``l3vni``, le VPC se comporte comme +avant. Le champ exige la section ``bgp`` de l'agent (:doc:`/exploitation/configuration`) et ne +se change pas après création. + +**Plan de VNI.** L3VNI et ``vxlan_id`` des subnets partagent l'espace des VNI VXLAN : la plage +**1–65535** (sauf 253–255, tables du noyau) est réservée aux L3VNI des VPC, **65536–16777215** aux +subnets. L'agent n'impose que la première borne (le RD ``:`` porte un numéro sur +16 bits) ; le respect du plan revient à l'appelant, qui alloue les deux. + +À la création, l'agent pose sur l'hyperviseur, pour un VPC ``vp-`` : + +.. code-block:: text + + vrf- VRF, table de routage = l3vni + ├── brl3- bridge sans adresse, MAC de routeur 02:02: + │ └── vxl3- VXLAN du l3vni, VTEP = IPv4 primaire de default_interface + └── l3--o 169.254.0.1/30 ── l3--i 169.254.0.2/30, dans le netns du VPC + +Dans le netns, le ``cidr`` du VPC est routé vers ``169.254.0.1`` ; le transit ``/30`` est le même +sur tous les hyperviseurs et pour tous les VPC. L'agent active le forwarding IPv4 dans le netns, +et sur l'hôte sur ``brl3-`` et ``l3--o``, les deux interfaces d'entrée de la VRF ; il ne +touche pas au réglage global, que ``bootstrap_kvm.sh`` met déjà à 1. FRR reçoit la VRF, son ``vni``, une instance +``router bgp vrf vrf-`` avec RD ``:`` et RT ``:``, et +l'export des routes du ``cidr`` présentes dans la VRF. + +La suppression retire d'abord la configuration de routage de FRR, puis les interfaces, puis la +VRF de FRR. Cet ordre est imposé : supprimer la VRF du noyau sous une instance BGP encore +configurée fait planter ``bgpd`` (FRR 10.7.1). + Subnet ------ @@ -34,6 +68,11 @@ hosts dont le nommage réseau diffère. Le comportement réseau dépend du :doc:`mode `. +Un subnet ne peut être supprimé que si aucune VM non supprimée n'a d'interface dessus — sinon +409, avec la liste des VM. Dans un VPC routé par ``l3vni``, un subnet ``vxlan`` annonce son +préfixe dans la VRF du VPC à la création et le retire en premier à la suppression : c'est le +filet qui couvre une VM tant que son ``/32`` n'est pas annoncé. + VM -- @@ -44,6 +83,12 @@ le nom de l'interface dans le guest. Exactement une interface doit être ``prima la route par défaut et le serveur de metadata. Tous les subnets d'une VM doivent appartenir au **même VPC**. +**Routes.** Dans un VPC routé par ``l3vni``, chaque interface sur un subnet ``vxlan`` est annoncée +en ``/32`` dans la VRF du VPC une fois QEMU démarré, juste avant le passage en ``running``. À la +suppression, ces ``/32`` sont retirés **avant** l'arrêt de QEMU. Comme un subnet ne peut être +supprimé tant qu'une VM l'utilise, le ``/32`` d'une VM est toujours retiré avant le ``/24`` de son +subnet — l'ordre qui évite le trou noir de `#41 `_. + **Stockage.** Un seul disque ``vdX`` (virtio-blk) par VM ; les disques supplémentaires passent par le contrôleur SCSI (``sdX``). Cette contrainte vient de la carte PCI figée — voir :doc:`/architecture/contraintes`. diff --git a/docs/deploiement/premier-hyperviseur.rst b/docs/deploiement/premier-hyperviseur.rst index dc480fe..1958005 100644 --- a/docs/deploiement/premier-hyperviseur.rst +++ b/docs/deploiement/premier-hyperviseur.rst @@ -27,11 +27,41 @@ l'agent désactive l'apprentissage et ne configure aucun voisin — cf. Configuration de FRR ~~~~~~~~~~~~~~~~~~~~ -Seul ``bgpd`` est activé dans ``/etc/frr/daemons``. D'un hyperviseur à l'autre ne changent que -``hostname`` et ``router-id``, l'adresse de l'hyperviseur sur son segment. +Seul ``bgpd`` est activé dans ``/etc/frr/daemons``. Le reste est posé par l'agent, à chaque +démarrage, à partir de la section ``bgp`` de ``agent.yml`` (:doc:`/exploitation/configuration`) : -.. literalinclude:: ../../test/e2e/topologies/frr/hv1.conf - :language: text +.. code-block:: yaml + + bgp: + asn: 64600 + route_reflectors: [10.255.255.1] + +L'agent en déduit la configuration ci-dessous ; le ``router-id`` est l'adresse IPv4 primaire de +``default_interface``, la seule valeur qui change d'un hyperviseur à l'autre. ``hostname`` et +``log`` ne sont pas gérés par l'agent : ce sont les seules lignes à déposer dans ``frr.conf``. + +.. code-block:: text + + router bgp 64600 + bgp router-id 192.168.14.11 + no bgp default ipv4-unicast + neighbor fabric peer-group + neighbor fabric remote-as 64600 + neighbor fabric capability extended-nexthop + neighbor 10.255.255.1 peer-group fabric + ! + address-family l2vpn evpn + neighbor fabric activate + advertise-all-vni + exit-address-family + exit + +.. warning:: + + Avec une section ``bgp``, l'agent **refuse de démarrer** si ``vtysh`` ne répond pas, et + ``agent.service`` ne le relance pas. L'ordre au démarrage est donc : migration réseau vers + ``br-000000``, **puis** FRR, **puis** l'agent. FRR démarré avant la migration peut perdre la + route par défaut quand elle change d'interface, et ne plus joindre le route reflector. Ce qu'elle établit : diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index 6e01936..d45aa3d 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -112,15 +112,16 @@ Commandes et le prix ; ne crée rien up crée le serveur de lab, attend la fin de son installation et son SSH, puis le prépare (voir prepare) - status liste les serveurs de lab du projet + status liste les serveurs de lab du projet, dans toutes les zones candidates ssh [commande] se connecte au serveur de lab ; avec une commande, un terminal n'est demandé que si l'entrée standard en est un prepare installe sur le serveur ce dont lab a besoin (qemu, genisoimage), vérifie - /dev/kvm et la virtualisation imbriquée ; lancé aussi par up + /dev/kvm, la virtualisation imbriquée et un CPU x86-64-v3 ; lancé aussi par up push compile cmd/lab pour linux/amd64 et dépose sur le serveur ~/lab et le répertoire de la topologie dans ~/topology/ (avec les fichiers qu'elle référence) ; ensuite : ssh './lab up topology/' - down supprime tous les serveurs de lab du projet et attend leur disparition + down supprime tous les serveurs de lab du projet, dans toutes les zones candidates, + et attend leur disparition session [cmd] up, puis la commande distante (ou un shell), puis down quoi qu'il arrive ``plan`` et ``status`` sont **gratuits** ; ``up`` et ``session`` **créent un serveur facturé**. @@ -131,11 +132,27 @@ et montre exactement ce qui serait commandé : .. code-block:: text $ scripts/lab-host.sh plan - == offre : EM-B212X-SSD (ddaf8ba6-b2b2-4279-8af3-51930fb602f8), facturation hourly, stock available - == prix : 0.321 EUR HT par heure, frais de mise en service 0 EUR + !! fr-par-1 : offre EM-B420E-NVME en rupture de stock en fr-par-1 + !! fr-par-2 : offre EM-B420E-NVME en rupture de stock en fr-par-2 + !! nl-ams-1 : offre horaire EM-B420E-NVME : 0 correspondance(s) en nl-ams-1, une seule attendue + == zone : nl-ams-2 + == offre : EM-B420E-NVME (d14eef5e-3279-42db-bb57-bb2bbe6a5b28), AMD EPYC 7272, facturation hourly, stock available + == prix : 0.444 EUR HT par heure, frais de mise en service 0 EUR == os : Debian 12 (Bookworm) (83640d93-a0b8-45ad-9c9f-30cae48380a4), utilisateur root == clés : 2 clé(s) SSH du projet - == requête : POST /baremetal/v1/zones/fr-par-1/servers + == requête : POST /baremetal/v1/zones/nl-ams-2/servers + +**Offre et zone.** L'offre par défaut est ``EM-B420E-NVME`` (AMD EPYC 7272, 12 cœurs, 119 Gio) : +son modèle de CPU est exact et atteint **x86-64-v3**, le minimum de RHEL 10 et Rocky 10. Les offres +« Xeon … or equivalent » ne garantissent rien : ``EM-B212X-SSD`` (« E5-2620 v4 or equivalent ») a +livré le 2026-10-11 un E5-2670 de 2012, x86-64-v2, sur lequel Rocky 10 ne démarre pas. +``prepare`` refuse donc un serveur sans x86-64-v3 — dans une ``session``, il est aussitôt +supprimé. La zone n'est pas imposée : ``plan`` et ``up`` prennent la première zone de +``LAB_ZONES`` (par défaut toutes les zones Elastic Metal) où l'offre est en stock, ``SCW_DEFAULT_ZONE`` +passant en tête ; ``status`` et ``down`` couvrent toutes ces zones. Une zone dont la liste échoue +est signalée sans masquer les autres : ``status`` affiche ce qui a répondu, ``down`` supprime les +serveurs listés, et tous deux sortent en erreur ; ``up`` refuse de créer tant qu'une zone reste +inconnue. ``session`` est la forme normale d'usage : le serveur est supprimé à la fin, que la commande réussisse, échoue, ou que la session soit interrompue (Ctrl-C, ``TERM``, fermeture du terminal). @@ -231,12 +248,14 @@ Ce que le fichier déclare : * ``frr`` — le chemin d'un ``frr.conf``, relatif au fichier de topologie : FRR est installé au démarrage et la configuration déposée **telle quelle** (voir `Rôles`_). * ``release`` — **obligatoire pour un hyperviseur**, refusé ailleurs : le tag de la release de - two que ``deploy.sh`` installe (``release: 0.2.0rc003``). Sans lui, ``deploy.sh`` prendrait la + two que ``deploy.sh`` installe (``release: 0.2.0rc008``). Sans lui, ``deploy.sh`` prendrait la dernière release, et le lab ne serait plus reproductible. * ``agent`` — pour un hyperviseur seulement : le chemin d'un ``agent.yml``, relatif au fichier de topologie, déposé dans ``/etc/two/agent.yml`` avant ``deploy.sh``. Sans lui, l'agent tourne - avec sa configuration par défaut. L'exemple met hv1 sur le serveur DHCP intégré - (``test/e2e/topologies/agent/two.yml`` : ``dhcp.backend: two``) et laisse hv2 sur dnsmasq. + avec sa configuration par défaut. Les deux fichiers fournis donnent à l'agent la section + ``bgp`` (AS 64600, route reflector ``10.255.255.1``) et un watchdog toutes les 10 s ; + ``test/e2e/topologies/agent/two.yml`` met en plus hv1 sur le serveur DHCP intégré + (``dhcp.backend: two``), ``agent/bgp.yml`` laisse les autres sur dnsmasq. ``mgmt0`` et ``lo1`` sont réservés : aucun segment ne peut porter ces noms. @@ -286,8 +305,8 @@ Limites : 1000 nœuds, 256 segments, et autant de câbles que la plage UDP le pe name loopback secondary frr release agent sw1 - underlay 169.254.0.1/28 sw1.conf - - rr1 lo1 10.255.255.1/32 underlay 169.254.0.3/28 rr1.conf - - - hv1 - - hv1.conf 0.2.0rc003 two.yml - hv2 - - hv2.conf 0.2.0rc003 - + hv1 - - hv1.conf 0.2.0rc008 two.yml + hv2 - - hv2.conf 0.2.0rc008 bgp.yml segment underlay: 192.168.14.0/24, mtu 9000, switch sw1, bridge br-underlay, gateway 192.168.14.1 node interface address mac udp switch port mac udp @@ -319,7 +338,9 @@ Rôles Les configurations FRR du lab vivent dans ``test/e2e/topologies/frr/``, une par nœud, **écrites à la main** : ce sont les mêmes fichiers que la documentation de déploiement inclut, pour que le lab qualifie -exactement ce qu'elle prescrit. Celle du route reflector : +exactement ce qu'elle prescrit. Celles des hyperviseurs se réduisent à ``hostname`` et ``log`` : +la configuration BGP est posée par l'agent (section ``bgp`` de ``agent.yml``). Celle du route +reflector : .. literalinclude:: ../../test/e2e/topologies/frr/rr1.conf :language: text @@ -357,7 +378,12 @@ teste les scripts de sa branche. L'uplink ``-u`` est l'interface qui porte la ro celle du premier segment de l'hyperviseur dans l'ordre de déclaration des segments — parce que ``deploy.sh`` y lit l'adresse et la passerelle qu'il déplace sur ``br-000000``. ``deploy.sh`` télécharge la release sur ``git.g3e.fr`` sans réessayer : le lancement attend d'abord que le serveur -réponde, à travers le switch. FRR est installé **après** : il démarre sur le réseau final. +réponde, à travers le switch. FRR est installé **après** : il démarre sur le réseau final. Démarré +avant la migration, zebra peut perdre la route par défaut quand elle passe de l'uplink à +``br-000000`` — constaté le 2026-10-11 sur un hyperviseur sur deux : route reflector +``unresolved``, session BGP jamais établie. L'agent, configuré avec une section ``bgp``, refuse de +démarrer tant que FRR n'est pas là : son premier démarrage par ``deploy.sh`` échoue, et le +provisionnement le **redémarre** une fois FRR installé. **Un seul script de provisionnement par nœud.** cloud-init exécute ``runcmd`` comme un script ``sh`` sans ``set -e`` : seule la dernière commande compte, et un ``deploy.sh`` en échec suivi d'un @@ -717,6 +743,30 @@ sortie vaut 1 si une vérification échoue **ou si aucune n'a été faite**. le trafic restant est **mesuré** (``INFO``) à 30 et 90 s ; au retour du route reflector, le VTEP distant est réappris et le trafic repasse — délai mesuré - hv1, hv2, rr1 + * - ``s7-l3vni`` + - qualification de `#41 `_ **par l'API** : VPC créées + avec une ``l3vni``, l'agent pose VRF, L3VNI, transit, FRR et les routes de type 5 (``/24`` + des subnets, ``/32`` des VM). Deux subnets d'une même VPC, chacun sur un seul hyperviseur, + se joignent par le L3VNI à travers le route reflector inchangé ; 1472 octets en ``-M do`` ; + une seconde VPC de même plage sur un autre L3VNI n'est ni importée ni jointe ; L3VNI déjà + prise refusée ; forwarding de l'hôte limité aux interfaces de la VRF ; suppression d'un + subnet refusée tant qu'une VM l'utilise ; démontage complet d'une VPC sans redémarrage de + bgpd + - hv1, hv2, rr1 + * - ``s8-l3vni-migration`` + - suite de ``s7``, topologie ``evpn-3hv.yml`` : migration d'une VM de hv1 vers hv2 par l'API, + observée depuis hv3 qui n'a pas le subnet : migration simple (VM supprimée puis recréée, + ``/24`` comme filet), séquence orchestrée (deux VM de même IP, deux ``/32`` en ECMP, 40 + sources sur 40) ; l'ancien « pire cas » devient un refus (409) ; MAC de gateway propre à + chaque hôte, sans doublon EVPN ; watchdog : ``/32`` orphelin signalé comme trou noir, ``/32`` manquant + signalé + - hv1, hv2, hv3, rr1 + * - ``s9-subnets-partages`` + - deux VPC, avec et sans ``l3vni``, chacune avec deux subnets présents sur **les deux** + hyperviseurs et une VM par subnet et par hôte : ping entre toutes les paires (même subnet ou + non, même hôte ou non) ; chaque VM voit la MAC de gateway de son propre hôte ; aucune MAC en + double sur les quatre VNI + - hv2, hv3, rr1 ``s6`` réutilise les VM de ``s4`` : le lancer après. @@ -724,7 +774,9 @@ sortie vaut 1 si une vérification échoue **ou si aucune n'a été faite**. scénario envoie des blocs de shell aux nœuds par ``on [VAR=valeur…] <<'NODE'``, précédés de ``test/e2e/lib/node.sh`` — appels à l'API de l'agent, attente des états, image Debian compatible two (préparée une fois par hyperviseur, ``seedfrom`` avec barre oblique finale), clé SSH des VM, -``check`` et ``vm_fails``. Une vérification négative (« ne joint pas ») passe par ``vm_fails`` : +``check`` et ``vm_fails`` ; pour #41, ``vpc_create`` avec une ``l3vni``, ``api_code`` (code HTTP +d'un refus attendu), l'observation des VRF et de BGP (``vrf_nexthops``, ``bgp_paths``, +``wait_l3vni``…) et ``wait_watchdog`` (alerte du watchdog dans le journal de l'agent). Une vérification négative (« ne joint pas ») passe par ``vm_fails`` : elle n'est réussie que si le SSH vers la VM a fonctionné **et** que la commande y a échoué — un SSH en panne ne passe jamais pour une isolation. @@ -751,6 +803,77 @@ dérive la MAC du rang de l'IP, et les VM ``.10``/``.11`` des deux subnets avaie Vérifié à la main sur le lab, chaque serveur DHCP ne connaissait que les couples MAC/IP de son subnet ; le scénario compare désormais ces couples. +``s7-l3vni`` le 2026-10-05, même lab, FRR 10.7.1 : **46 réussi(s), 0 échoué(s)** au dernier run. +Quatre constats pour #41, au-delà du routage inter-subnet qui fonctionne avec le route reflector +inchangé : + +* **bgpd 10.7.1 plante** (SIGSEGV dans ``bgp_redistribute_add``) quand la VRF du noyau est + supprimée puis recréée sous une instance ``router bgp … vrf`` encore configurée — FRR refuse de + supprimer l'instance tant que ``vni`` est déclaré dans la VRF (« Please unconfigure l3vni »). + Le plantage a touché les deux hyperviseurs à une seconde d'intervalle. Avec le démontage dans + l'ordre — ``no redistribute``, ``no vni``, ``no router bgp … vrf``, puis le noyau —, trois runs + consécutifs passent sans plantage. +* **La configuration posée par vtysh est perdue** au redémarrage de bgpd par watchfrr, qui + relit ``frr.conf`` seul. +* **Le transit** ``169.254.0.0/30``, **identique sur tous les hôtes**, fait rejeter comme + « martiens » les ICMP émis par les sauts distants (VRF et netns de l'hôte de sortie) : le + noyau de l'hôte d'entrée possède la même adresse. Quatre routeurs sur le chemin, seuls les + deux premiers répondent. Même effet attendu sur un ICMP « fragmentation nécessaire ». +* **La route du supernet n'existe pas dans le netns** de la VPC avant la pose manuelle (premier + run, lab neuf) : two ne pose que la route connectée du subnet. + +``s8-l3vni-migration`` le 2026-10-06, ``evpn-3hv.yml`` : **61 réussi(s), 0 échoué(s)**. Le filet du +``/24`` porte le trafic tant que la destination n'a pas annoncé son ``/32`` ; deux ``/32`` +coexistent sans perte tant que la source garde le subnet (40 sources sur 40, relais en L2). Si la +source supprime le subnet avant de retirer son ``/32``, le trou noir est **stable mais partiel** : +hv3 installe les deux chemins en ECMP, et seuls les flux hachés vers la source échouent (17 sources +sur 40) — invisible avec un seul émetteur. + +Le 2026-10-11, les mêmes qualifications **par l'API**, l'agent posant toute la configuration +(FRR 10.7.1) : + +* ``s1`` à ``s6`` sur ``evpn-2hv.yml``, release ``0.2.0rc004``, base BGP des hyperviseurs posée par + l'agent : 37, 22, 12, 14, 13 et 8 réussis, aucun échec. +* Puis, release ``0.2.0rc005`` (correction du démontage FRR, ci-dessous), ``evpn-3hv.yml`` : +* ``s7-l3vni`` : **52 réussi(s), 1 échoué(s)**. Routage inter-subnet par le + L3VNI, MAC de routeur dérivée du VTEP, exports ``/24`` et ``/32`` automatiques, forwarding par + interface, L3VNI en double et subnet utilisé refusés (409), démontage complet d'une VPC sans + redémarrage de bgpd. L'échec — « TTL 1 », un seul paquet — ne s'est pas reproduit au run + précédent : probablement le débit limité des ICMP du noyau ; la vérification envoie désormais + trois paquets. +* ``s8-l3vni-migration`` : **48 réussi(s), 1 échoué(s)**. Migration simple (``/32`` de la + destination installé sur hv3 sans délai mesurable, 50/50), séquence orchestrée (deux ``/32`` en + ECMP, 40 sources sur 40), ex-pire cas refusé (409), watchdog : ``/32`` orphelin signalé comme + trou noir, ``/32`` manquant signalé. L'échec est un constat : **la MAC de gateway anycast est + annoncée en EVPN** (route de type 2 sur rr1) et FRR la déclare en double sur la VNI du subnet + porté par deux hyperviseurs — apprise sur le veth du subnet, numéros de séquence croissants. + +Trois défauts trouvés et corrigés pendant la campagne : + +* **FRR installé avant la migration réseau** : zebra a perdu la route par défaut sur un + hyperviseur sur deux (route reflector ``unresolved``). Retour à l'ordre « FRR après + ``deploy.sh`` », puis redémarrage de l'agent (voir `Rôles`_). +* **Remarques de vtysh prises pour des erreurs** : ``no vni`` répond + ``% Configuration applied with notes:`` avec un code de retour 0. Une vraie erreur (commande + inconnue, refus) sort en 1. +* **L3VNI libérée de façon asynchrone** : juste après ``no vni``, ``no router bgp … vrf`` peut être + refusé (« Please unconfigure l3vni ») puis accepté un instant plus tard ; l'agent réessaie. + +Le 2026-10-12, release ``0.2.0rc006``, ``evpn-3hv.yml`` : ``s1`` à ``s7`` sans échec, +``s8-l3vni-migration`` **50 réussi(s), 0 échoué(s)** (MAC de gateway propre à chaque hôte, aucun +doublon EVPN), ``s9-subnets-partages`` **75 réussi(s), 1 échoué(s)**. L'échec est une session SSH +coupée (``Broken pipe``), pas un ping perdu : quand un hôte route vers une VM d'un autre hôte, son +netns émet une requête ARP au nom de la gateway, partagée par tous les hôtes ; la VM met son cache à +jour et, pendant ~8 s, envoie à la gateway de l'autre hôte ce qui était destiné à la sienne. +Détails et suite : `#57 `_. + +.. note:: + + Un ``Broken pipe`` (``client_loop: send disconnect``) ou une session SSH figée dans un scénario + n'est **pas forcément un aléa du lab** : c'est la signature de ce problème. Ne pas le classer + comme test instable ni ajouter un nouvel essai qui le masquerait ; regarder d'abord le cache ARP + de la VM (``ip neigh show ``) et l'état de la session côté VM. + Les VM sont accessibles depuis le netns de leur VPC, sur l'hyperviseur, avec l'utilisateur ``syonad`` créé par les métadonnées de two : diff --git a/docs/exploitation/api-agent/asynchronisme.rst b/docs/exploitation/api-agent/asynchronisme.rst index a506d55..afcee1d 100644 --- a/docs/exploitation/api-agent/asynchronisme.rst +++ b/docs/exploitation/api-agent/asynchronisme.rst @@ -71,7 +71,8 @@ Codes de retour - ressource inexistante * - ``409`` - conflit d'existence ou d'état : ressource déjà créée, ou suppression depuis un état qui - ne l'autorise pas ; pour un VPC, subnets encore présents + ne l'autorise pas ; pour un VPC, subnets encore présents ; pour un subnet, VM non + supprimées qui l'utilisent encore * - ``422`` - dépendance absente ou pas prête : VPC parent d'un subnet, subnet d'une VM * - ``500`` diff --git a/docs/exploitation/configuration.rst b/docs/exploitation/configuration.rst index 7024527..8c364b0 100644 --- a/docs/exploitation/configuration.rst +++ b/docs/exploitation/configuration.rst @@ -104,6 +104,38 @@ Traduit les clés logiques ``iface_type`` de l'API vers les bridges physiques de inconnue ou omise retombe silencieusement sur ``default_interface`` — ce n'est pas une erreur, mais c'est une source de subnets branchés au mauvais endroit sans le dire. +Plan de contrôle BGP +-------------------- + +.. code-block:: yaml + + bgp: + asn: 64600 + route_reflectors: [10.255.255.1] + +Section **facultative**. Absente, l'agent ne touche pas à FRR : sa configuration reste à poser +à la main, comme avant. Présente, l'agent **pilote la configuration BGP de l'hyperviseur** : +à chaque démarrage, avant d'ouvrir son API, il applique par ``vtysh`` la base décrite dans +:doc:`/deploiement/premier-hyperviseur`, puis l'enregistre par ``write memory``. + +* ``asn`` — l'AS de l'hyperviseur, commun à tous les hyperviseurs du cluster (iBGP vers le + route reflector). Obligatoire dès que la section existe. +* ``route_reflectors`` — au moins une adresse IPv4, sans doublon. Un route reflector retiré de + la liste est retiré de FRR au démarrage suivant. + +Le ``router-id`` n'est pas configurable : c'est l'adresse IPv4 primaire de +``default_interface``, celle qui sert de VTEP. + +Le démarrage **échoue** si la section est incomplète, si ``default_interface`` n'a pas +d'adresse IPv4 primaire, si ``vtysh`` refuse une commande, ou si FRR tourne déjà sous un autre +AS : changer d'``asn`` suppose de retirer l'ancienne instance à la main. + +.. warning:: + + ``/etc/frr/frr.conf`` devient un fichier **généré** : ``write memory`` le réécrit à partir de + la configuration en mémoire de FRR. Une modification faite dans le fichier sans être + rechargée est perdue au prochain démarrage de l'agent. + Metadata et QEMU ---------------- diff --git a/docs/exploitation/observabilite.rst b/docs/exploitation/observabilite.rst index b8f7a4c..6602dfa 100644 --- a/docs/exploitation/observabilite.rst +++ b/docs/exploitation/observabilite.rst @@ -38,6 +38,21 @@ toujours sur le système, et **notifie les écarts sans jamais réparer**. Il contrôle notamment l'existence des network namespaces, des liens réseau des subnets, des taps de VM et la réponse des units systemd associées. +Avec une section ``bgp`` dans la configuration, il contrôle aussi le plan de contrôle : + +* **Sessions BGP** : une notification par route reflector dont la session n'est pas + ``Established`` (``show bgp neighbors ``). +* **VPC routés** (``l3vni``, état ``running``) : présence et état des interfaces ``vrf-``, + ``brl3-``, ``vxl3-``, ``l3--o`` et, dans le netns, ``l3--i`` ; L3VNI de type + ``L3``, ``Up``, avec la MAC de routeur attendue (``show evpn vni ``). +* **Réconciliation des routes exportées** dans la VRF : chaque ``/24`` de subnet ``vxlan`` et chaque + ``/32`` d'interface de VM ``running`` doit être exporté ; à l'inverse, une route exportée dont + le propriétaire n'existe plus — ni ``running``, ni en ``creating``, ``deleting`` ou ``error`` — + est signalée comme un **trou noir** : l'annonce attire du trafic que plus rien ne reçoit. + +Un VPC routé alors que la section ``bgp`` a disparu de la configuration est signalé lui aussi. Il +reste supprimable : le démontage lit l'AS de son instance dans la configuration courante de FRR. + .. note:: Un écart persistant est signalé **à chaque tick**, sans déduplication. Le volume de diff --git a/internal/api/agent/helpers_test.go b/internal/api/agent/helpers_test.go index c7162c7..69adfb2 100644 --- a/internal/api/agent/helpers_test.go +++ b/internal/api/agent/helpers_test.go @@ -16,11 +16,15 @@ import ( // The worker queue is buffered but has no running goroutines: Dispatch enqueues // without blocking and Execute never runs, so DB state reflects only Prepare writes. func newTestServer(t *testing.T) (*Server, *badger.DB) { + t.Helper() + return newTestServerWith(t, &configuration.Config{DefaultInterface: "br-test"}) +} + +func newTestServerWith(t *testing.T, cfg *configuration.Config) (*Server, *badger.DB) { t.Helper() db := kv.InitDB(kv.Config{Path: t.TempDir()}, false) t.Cleanup(func() { db.Close() }) q := worker.New(100) - cfg := &configuration.Config{DefaultInterface: "br-test"} logger := slog.New(slog.NewTextHandler(io.Discard, nil)) d := dispatcher.New(q, db, cfg, logger) return New(d, db, logger, "127.0.0.1:0"), db diff --git a/internal/api/agent/models.go b/internal/api/agent/models.go index f30ddf0..de01684 100644 --- a/internal/api/agent/models.go +++ b/internal/api/agent/models.go @@ -1,14 +1,16 @@ package agentapi type VPCCreateRequest struct { - Name string `json:"name"` - CIDR string `json:"cidr"` + Name string `json:"name"` + CIDR string `json:"cidr"` + L3VNI *uint32 `json:"l3vni,omitempty"` } type VPC struct { Name string `json:"name"` State string `json:"state"` CIDR string `json:"cidr"` + L3VNI uint32 `json:"l3vni,omitempty"` } type SubnetCreateRequest struct { diff --git a/internal/api/agent/vpc.go b/internal/api/agent/vpc.go index bb3f5d7..33e4002 100644 --- a/internal/api/agent/vpc.go +++ b/internal/api/agent/vpc.go @@ -36,8 +36,9 @@ func (s *Server) getVpc(w http.ResponseWriter, _ *http.Request, name string) { return } cidr, _ := kv.GetFromDB(s.db, "vpc/"+name+"/cidr") + l3vni, _ := kv.GetFromDB(s.db, "vpc/"+name+"/l3vni") w.WriteHeader(http.StatusOK) - json.NewEncoder(w).Encode(VPC{Name: name, State: state, CIDR: cidr}) + json.NewEncoder(w).Encode(VPC{Name: name, State: state, CIDR: cidr, L3VNI: parseL3VNI(l3vni)}) } func (s *Server) deleteVpc(w http.ResponseWriter, _ *http.Request, name string) { diff --git a/internal/api/agent/vpc_test.go b/internal/api/agent/vpc_test.go index b5ba517..8578b57 100644 --- a/internal/api/agent/vpc_test.go +++ b/internal/api/agent/vpc_test.go @@ -5,9 +5,12 @@ import ( "encoding/json" "net/http" "net/http/httptest" + "strings" "testing" + configuration "git.g3e.fr/syonad/two/internal/config/agent" "git.g3e.fr/syonad/two/pkg/db/kv" + "github.com/dgraph-io/badger/v4" ) // --- VpcsHandler --- @@ -236,3 +239,85 @@ func TestVpcByName_InvalidMethod(t *testing.T) { t.Errorf("attendu 405, obtenu %d", w.Code) } } + +func newBGPTestServer(t *testing.T) (*Server, *badger.DB) { + cfg := &configuration.Config{DefaultInterface: "br-test"} + cfg.BGP.ASN = 64600 + cfg.BGP.RouteReflectors = []string{"10.255.255.1"} + return newTestServerWith(t, cfg) +} + +func postVpcJSON(s *Server, body string) *httptest.ResponseRecorder { + w := httptest.NewRecorder() + s.VpcsHandler(w, httptest.NewRequest(http.MethodPost, "/vpcs", strings.NewReader(body))) + return w +} + +func TestPostVpc_WithL3VNI(t *testing.T) { + s, db := newBGPTestServer(t) + w := postVpcJSON(s, `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":4001}`) + if w.Code != http.StatusAccepted { + t.Fatalf("attendu 202, obtenu %d: %s", w.Code, w.Body.String()) + } + if !strings.Contains(w.Body.String(), `"l3vni":4001`) { + t.Errorf("réponse sans l3vni : %s", w.Body.String()) + } + if got, _ := kv.GetFromDB(db, "vpc/vp-1/l3vni"); got != "4001" { + t.Errorf("l3vni en DB = %q", got) + } +} + +func TestPostVpc_WithoutL3VNIOmitsTheField(t *testing.T) { + s, _ := newBGPTestServer(t) + w := postVpcJSON(s, `{"name":"vp-1","cidr":"10.0.0.0/16"}`) + if w.Code != http.StatusAccepted || strings.Contains(w.Body.String(), "l3vni") { + t.Errorf("%d : %s", w.Code, w.Body.String()) + } +} + +func TestPostVpc_RejectsAnInvalidL3VNIAsABadRequest(t *testing.T) { + s, db := newBGPTestServer(t) + for _, body := range []string{ + `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":0}`, + `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":255}`, + `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":65536}`, + `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":16777216}`, + `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":-1}`, + } { + if w := postVpcJSON(s, body); w.Code != http.StatusBadRequest { + t.Errorf("%s : attendu 400, obtenu %d: %s", body, w.Code, w.Body.String()) + } + } + if entries, _ := kv.ListByPrefix(db, "vpc/"); len(entries) != 0 { + t.Errorf("écritures malgré le refus : %v", entries) + } +} + +func TestPostVpc_L3VNIWithoutBGPIsAConflict(t *testing.T) { + s, _ := newTestServer(t) + w := postVpcJSON(s, `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":4001}`) + if w.Code != http.StatusConflict || !strings.Contains(w.Body.String(), "requires the bgp section") { + t.Errorf("%d : %s", w.Code, w.Body.String()) + } +} + +func TestGetAndListVpc_ReturnTheL3VNI(t *testing.T) { + s, db := newTestServer(t) + kv.AddInDB(db, "vpc/vp-1/state", "running") + kv.AddInDB(db, "vpc/vp-1/cidr", "10.0.0.0/16") + kv.AddInDB(db, "vpc/vp-1/l3vni", "4001") + w := httptest.NewRecorder() + s.VpcByNameHandler(w, httptest.NewRequest(http.MethodGet, "/vpcs/vp-1", nil)) + var got VPC + json.NewDecoder(w.Body).Decode(&got) + if got.L3VNI != 4001 { + t.Errorf("GET : l3vni = %d", got.L3VNI) + } + w = httptest.NewRecorder() + s.VpcsHandler(w, httptest.NewRequest(http.MethodGet, "/vpcs", nil)) + var list []VPC + json.NewDecoder(w.Body).Decode(&list) + if len(list) != 1 || list[0].L3VNI != 4001 { + t.Errorf("liste : %+v", list) + } +} diff --git a/internal/api/agent/vpcs.go b/internal/api/agent/vpcs.go index 905cdee..17110d2 100644 --- a/internal/api/agent/vpcs.go +++ b/internal/api/agent/vpcs.go @@ -4,9 +4,11 @@ import ( "encoding/json" "net" "net/http" + "strconv" "strings" dispatcher "git.g3e.fr/syonad/two/internal/dispatcher/agent" + "git.g3e.fr/syonad/two/internal/l3vni" "git.g3e.fr/syonad/two/pkg/db/kv" ) @@ -44,6 +46,8 @@ func (s *Server) listVpcs(w http.ResponseWriter, _ *http.Request) { vpcs[name].State = value case "cidr": vpcs[name].CIDR = value + case "l3vni": + vpcs[name].L3VNI = parseL3VNI(value) } } result := make([]VPC, 0, len(vpcs)) @@ -77,6 +81,14 @@ func (s *Server) postVpc(w http.ResponseWriter, r *http.Request) { return } cmd := dispatcher.CreateVPCCommand{Name: req.Name, CIDR: req.CIDR} + if req.L3VNI != nil { + if err := l3vni.Valid(*req.L3VNI); err != nil { + w.WriteHeader(http.StatusBadRequest) + json.NewEncoder(w).Encode(ErrorResponse{Error: err.Error()}) + return + } + cmd.L3VNI = *req.L3VNI + } if err := s.dispatcher.Prepare(cmd); err != nil { w.WriteHeader(http.StatusConflict) json.NewEncoder(w).Encode(ErrorResponse{Error: err.Error()}) @@ -90,5 +102,10 @@ func (s *Server) postVpc(w http.ResponseWriter, r *http.Request) { return } w.WriteHeader(http.StatusAccepted) - json.NewEncoder(w).Encode(VPC{Name: req.Name, State: state, CIDR: req.CIDR}) + json.NewEncoder(w).Encode(VPC{Name: req.Name, State: state, CIDR: req.CIDR, L3VNI: cmd.L3VNI}) +} + +func parseL3VNI(value string) uint32 { + id, _ := strconv.ParseUint(value, 10, 32) + return uint32(id) } diff --git a/internal/config/agent/bgp.go b/internal/config/agent/bgp.go new file mode 100644 index 0000000..e79cf54 --- /dev/null +++ b/internal/config/agent/bgp.go @@ -0,0 +1,38 @@ +package configuration + +import ( + "fmt" + "net" +) + +type BGP struct { + ASN uint32 `mapstructure:"asn"` + RouteReflectors []string `mapstructure:"route_reflectors"` +} + +func (b BGP) Enabled() bool { + return b.ASN != 0 || len(b.RouteReflectors) > 0 +} + +func (b BGP) Reflectors() ([]net.IP, error) { + if b.ASN == 0 { + return nil, fmt.Errorf("bgp.asn must be set") + } + if len(b.RouteReflectors) == 0 { + return nil, fmt.Errorf("bgp.route_reflectors must list at least one address") + } + seen := make(map[string]bool, len(b.RouteReflectors)) + ips := make([]net.IP, 0, len(b.RouteReflectors)) + for _, rr := range b.RouteReflectors { + ip := net.ParseIP(rr).To4() + if ip == nil { + return nil, fmt.Errorf("bgp.route_reflectors: %q is not an IPv4 address", rr) + } + if seen[ip.String()] { + return nil, fmt.Errorf("bgp.route_reflectors: %s is listed twice", ip) + } + seen[ip.String()] = true + ips = append(ips, ip) + } + return ips, nil +} diff --git a/internal/config/agent/bgp_test.go b/internal/config/agent/bgp_test.go new file mode 100644 index 0000000..4004d0a --- /dev/null +++ b/internal/config/agent/bgp_test.go @@ -0,0 +1,54 @@ +package configuration + +import ( + "strings" + "testing" +) + +func TestLoadConfig_BGPAbsentIsDisabled(t *testing.T) { + cfg, err := LoadConfig(writeConfig(t, "database:\n path: /tmp/two\n")) + if err != nil { + t.Fatalf("LoadConfig: %v", err) + } + if cfg.BGP.Enabled() { + t.Errorf("bgp enabled without a bgp section: %+v", cfg.BGP) + } +} + +func TestLoadConfig_ReadsTheBGPSection(t *testing.T) { + cfg, err := LoadConfig(writeConfig(t, "bgp:\n asn: 4200000000\n route_reflectors: [10.255.255.1, 10.255.255.2]\n")) + if err != nil { + t.Fatalf("LoadConfig: %v", err) + } + if !cfg.BGP.Enabled() || cfg.BGP.ASN != 4200000000 { + t.Fatalf("bgp = %+v", cfg.BGP) + } + rrs, err := cfg.BGP.Reflectors() + if err != nil { + t.Fatalf("Reflectors: %v", err) + } + if len(rrs) != 2 || rrs[0].String() != "10.255.255.1" || rrs[1].String() != "10.255.255.2" { + t.Errorf("reflectors = %v", rrs) + } +} + +func TestBGPReflectors_RejectsAnIncompleteOrInvalidSection(t *testing.T) { + cases := []struct { + bgp BGP + want string + }{ + {BGP{RouteReflectors: []string{"10.255.255.1"}}, "bgp.asn must be set"}, + {BGP{ASN: 64600}, "at least one address"}, + {BGP{ASN: 64600, RouteReflectors: []string{"rr1"}}, `"rr1" is not an IPv4 address`}, + {BGP{ASN: 64600, RouteReflectors: []string{"fd00::1"}}, `"fd00::1" is not an IPv4 address`}, + {BGP{ASN: 64600, RouteReflectors: []string{"10.255.255.1", "10.255.255.1"}}, "10.255.255.1 is listed twice"}, + } + for _, c := range cases { + if !c.bgp.Enabled() { + t.Errorf("%+v: Enabled() = false", c.bgp) + } + if _, err := c.bgp.Reflectors(); err == nil || !strings.Contains(err.Error(), c.want) { + t.Errorf("%+v: erreur %v, attendu %q", c.bgp, err, c.want) + } + } +} diff --git a/internal/config/agent/struct.go b/internal/config/agent/struct.go index 0f84a09..17ddd43 100644 --- a/internal/config/agent/struct.go +++ b/internal/config/agent/struct.go @@ -55,6 +55,7 @@ type Config struct { Enabled bool `mapstructure:"enabled"` IntervalSeconds int `mapstructure:"interval_seconds"` } `mapstructure:"watchdog"` + BGP BGP `mapstructure:"bgp"` DefaultInterface string `mapstructure:"default_interface"` Interfaces map[string]string `mapstructure:"interfaces"` } diff --git a/internal/dispatcher/agent/helpers_test.go b/internal/dispatcher/agent/helpers_test.go index c14f6a3..2e6cbcc 100644 --- a/internal/dispatcher/agent/helpers_test.go +++ b/internal/dispatcher/agent/helpers_test.go @@ -17,6 +17,7 @@ func newTestDispatcher(t *testing.T) (*Dispatcher, *badger.DB) { t.Cleanup(func() { db.Close() }) q := worker.New(100) q.Start(2) + t.Cleanup(q.Stop) cfg := &configuration.Config{DefaultInterface: "br-default"} cfg.Interfaces = map[string]string{"vms": "br-vms"} logger := slog.New(slog.NewTextHandler(io.Discard, nil)) diff --git a/internal/dispatcher/agent/subnet_commands.go b/internal/dispatcher/agent/subnet_commands.go index b2fb5f6..f6e7f2d 100644 --- a/internal/dispatcher/agent/subnet_commands.go +++ b/internal/dispatcher/agent/subnet_commands.go @@ -2,7 +2,9 @@ package dispatcher import ( "fmt" + "sort" "strconv" + "strings" "time" configuration "git.g3e.fr/syonad/two/internal/config/agent" @@ -101,9 +103,36 @@ func (c DeleteSubnetCommand) Prepare(db *badger.DB, _ *configuration.Config) err if !state.CanDelete(current) { return fmt.Errorf("subnet %q cannot be deleted while %s", c.Name, current) } + vms, err := vmsUsingSubnet(db, c.Name) + if err != nil { + return err + } + if len(vms) > 0 { + return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(vms, ", ")) + } return state.Set(db, c.Key(), state.Deleting) } +func vmsUsingSubnet(db *badger.DB, subnetName string) ([]string, error) { + entries, err := kv.ListByPrefix(db, "vm/") + if err != nil { + return nil, fmt.Errorf("failed to list vms: %w", err) + } + var users []string + for key, value := range entries { + parts := strings.Split(key, "/") + if len(parts) != 5 || parts[2] != "nic" || parts[4] != "subnet" || value != subnetName { + continue + } + if s, err := state.Get(db, "vm/"+parts[1]); err == nil && s == state.Deleted { + continue + } + users = append(users, parts[1]) + } + sort.Strings(users) + return users, nil +} + func (c DeleteSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error { if err := subnet.DeleteSubnet(db, c.Name, cfg); err != nil { return err diff --git a/internal/dispatcher/agent/subnet_commands_test.go b/internal/dispatcher/agent/subnet_commands_test.go index d94f5e4..3474df1 100644 --- a/internal/dispatcher/agent/subnet_commands_test.go +++ b/internal/dispatcher/agent/subnet_commands_test.go @@ -1,6 +1,7 @@ package dispatcher import ( + "strings" "testing" configuration "git.g3e.fr/syonad/two/internal/config/agent" @@ -327,3 +328,38 @@ func TestCreateSubnetCommand_Prepare_RejectsUnknownMode(t *testing.T) { t.Error("un mode inconnu doit être refusé") } } + +func TestDeleteSubnetCommand_Prepare_RefusedWhileAVMUsesIt(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-a/state", "running") + kv.AddInDB(db, "vm/i-gone/state", "deleted") + kv.AddInDB(db, "vm/i-gone/nic/0/subnet", "sn-a") + kv.AddInDB(db, "vm/i-other/state", "running") + kv.AddInDB(db, "vm/i-other/nic/0/subnet", "sn-b") + kv.AddInDB(db, "vm/i-b/state", "deleting") + kv.AddInDB(db, "vm/i-b/nic/0/subnet", "sn-b") + kv.AddInDB(db, "vm/i-b/nic/1/subnet", "sn-a") + kv.AddInDB(db, "vm/i-a/state", "error") + kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") + kv.AddInDB(db, "vm/i-c/state", "running") + kv.AddInDB(db, "vm/i-c/nic/0/subnet", "sn-a") + err := DeleteSubnetCommand{Name: "sn-a"}.Prepare(db, nil) + if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-b, i-c`) { + t.Fatalf("erreur %v", err) + } + if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "running" { + t.Errorf("état modifié malgré le refus : %q", s) + } +} + +func TestDeleteSubnetCommand_Prepare_AllowedOnceItsVMsAreDeleted(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-a/state", "running") + kv.AddInDB(db, "vm/i-gone/state", "deleted") + kv.AddInDB(db, "vm/i-gone/nic/0/subnet", "sn-a") + kv.AddInDB(db, "vm/i-other/state", "running") + kv.AddInDB(db, "vm/i-other/nic/0/subnet", "sn-b") + if err := (DeleteSubnetCommand{Name: "sn-a"}).Prepare(db, nil); err != nil { + t.Fatalf("Prepare a échoué : %v", err) + } +} diff --git a/internal/dispatcher/agent/vpc_commands.go b/internal/dispatcher/agent/vpc_commands.go index 9e26819..7404342 100644 --- a/internal/dispatcher/agent/vpc_commands.go +++ b/internal/dispatcher/agent/vpc_commands.go @@ -3,10 +3,12 @@ package dispatcher import ( "fmt" "net" + "strconv" "strings" "time" configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/l3vni" "git.g3e.fr/syonad/two/internal/state" "git.g3e.fr/syonad/two/internal/vpc" "git.g3e.fr/syonad/two/pkg/db/kv" @@ -14,27 +16,63 @@ import ( ) type CreateVPCCommand struct { - Name string - CIDR string + Name string + CIDR string + L3VNI uint32 } func (c CreateVPCCommand) Key() string { return "vpc/" + c.Name } -func (c CreateVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error { +func (c CreateVPCCommand) Prepare(db *badger.DB, cfg *configuration.Config) error { if _, err := kv.GetFromDB(db, "vpc/"+c.Name+"/state"); err == nil { return fmt.Errorf("vpc %q already exists", c.Name) } if _, _, err := net.ParseCIDR(c.CIDR); err != nil { return fmt.Errorf("invalid cidr %q: %w", c.CIDR, err) } + if c.L3VNI != 0 { + if err := c.checkL3VNI(db, cfg); err != nil { + return err + } + } if err := kv.AddInDB(db, "vpc/"+c.Name+"/cidr", c.CIDR); err != nil { return err } + if c.L3VNI != 0 { + if err := kv.AddInDB(db, "vpc/"+c.Name+"/l3vni", strconv.FormatUint(uint64(c.L3VNI), 10)); err != nil { + return err + } + } return state.Set(db, c.Key(), state.Creating) } -func (c CreateVPCCommand) Execute(db *badger.DB, _ *configuration.Config) error { - return vpc.CreateVPC(db, c.Name) +func (c CreateVPCCommand) checkL3VNI(db *badger.DB, cfg *configuration.Config) error { + if err := l3vni.Valid(c.L3VNI); err != nil { + return err + } + if cfg == nil || !cfg.BGP.Enabled() { + return fmt.Errorf("l3vni requires the bgp section in the agent configuration") + } + entries, err := kv.ListByPrefix(db, "vpc/") + if err != nil { + return fmt.Errorf("failed to list vpcs: %w", err) + } + want := strconv.FormatUint(uint64(c.L3VNI), 10) + for key, value := range entries { + parts := strings.Split(key, "/") + if len(parts) != 3 || parts[2] != "l3vni" || value != want { + continue + } + if s, err := state.Get(db, "vpc/"+parts[1]); err == nil && s == state.Deleted { + continue + } + return fmt.Errorf("l3vni %d is already used by vpc %q", c.L3VNI, parts[1]) + } + return nil +} + +func (c CreateVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) error { + return vpc.CreateVPC(db, c.Name, cfg) } type DeleteVPCCommand struct { diff --git a/internal/dispatcher/agent/vpc_commands_test.go b/internal/dispatcher/agent/vpc_commands_test.go index 78b3d98..862f9c2 100644 --- a/internal/dispatcher/agent/vpc_commands_test.go +++ b/internal/dispatcher/agent/vpc_commands_test.go @@ -1,8 +1,10 @@ package dispatcher import ( + "strings" "testing" + configuration "git.g3e.fr/syonad/two/internal/config/agent" "git.g3e.fr/syonad/two/pkg/db/kv" ) @@ -137,3 +139,81 @@ func TestDeleteVPCCommand_Prepare_AllowedWhenSubnetDeleting(t *testing.T) { t.Fatalf("Prepare devrait réussir si le subnet est deleting : %v", err) } } + +func bgpConfig() *configuration.Config { + cfg := &configuration.Config{} + cfg.BGP.ASN = 64600 + cfg.BGP.RouteReflectors = []string{"10.255.255.1"} + return cfg +} + +func TestCreateVPCCommand_Prepare_StoresTheL3VNI(t *testing.T) { + _, db := newTestDispatcher(t) + cmd := CreateVPCCommand{Name: "vpc-1", CIDR: "10.0.0.0/16", L3VNI: 4001} + if err := cmd.Prepare(db, bgpConfig()); err != nil { + t.Fatalf("Prepare a échoué : %v", err) + } + if got, err := kv.GetFromDB(db, "vpc/vpc-1/l3vni"); err != nil || got != "4001" { + t.Errorf("l3vni en DB = %q, %v ; attendu 4001", got, err) + } +} + +func TestCreateVPCCommand_Prepare_WithoutL3VNIStoresNothing(t *testing.T) { + _, db := newTestDispatcher(t) + cmd := CreateVPCCommand{Name: "vpc-1", CIDR: "10.0.0.0/16"} + if err := cmd.Prepare(db, nil); err != nil { + t.Fatalf("Prepare a échoué : %v", err) + } + if got, err := kv.GetFromDB(db, "vpc/vpc-1/l3vni"); err == nil { + t.Errorf("clé l3vni écrite : %q", got) + } +} + +func TestCreateVPCCommand_Prepare_RefusesAnL3VNIWithoutBGP(t *testing.T) { + _, db := newTestDispatcher(t) + cmd := CreateVPCCommand{Name: "vpc-1", CIDR: "10.0.0.0/16", L3VNI: 4001} + err := cmd.Prepare(db, &configuration.Config{}) + if err == nil || !strings.Contains(err.Error(), "requires the bgp section") { + t.Fatalf("erreur %v", err) + } + if entries, _ := kv.ListByPrefix(db, "vpc/"); len(entries) != 0 { + t.Errorf("écritures malgré le refus : %v", entries) + } +} + +func TestCreateVPCCommand_Prepare_RefusesAReservedL3VNI(t *testing.T) { + _, db := newTestDispatcher(t) + cmd := CreateVPCCommand{Name: "vpc-1", CIDR: "10.0.0.0/16", L3VNI: 254} + if err := cmd.Prepare(db, bgpConfig()); err == nil || !strings.Contains(err.Error(), "l3vni 254 is reserved") { + t.Fatalf("erreur %v", err) + } + if entries, _ := kv.ListByPrefix(db, "vpc/"); len(entries) != 0 { + t.Errorf("écritures malgré le refus : %v", entries) + } +} + +func TestCreateVPCCommand_Prepare_RefusesAnL3VNIAlreadyUsed(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vpc/vpc-a/state", "deleting") + kv.AddInDB(db, "vpc/vpc-a/l3vni", "4001") + cmd := CreateVPCCommand{Name: "vpc-b", CIDR: "10.0.0.0/16", L3VNI: 4001} + err := cmd.Prepare(db, bgpConfig()) + if err == nil || !strings.Contains(err.Error(), `l3vni 4001 is already used by vpc "vpc-a"`) { + t.Fatalf("erreur %v", err) + } + if _, err := kv.GetFromDB(db, "vpc/vpc-b/state"); err == nil { + t.Error("vpc-b créé malgré le doublon") + } +} + +func TestCreateVPCCommand_Prepare_ReusesTheL3VNIOfADeletedVPC(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vpc/vpc-a/state", "deleted") + kv.AddInDB(db, "vpc/vpc-a/l3vni", "4001") + kv.AddInDB(db, "vpc/vpc-c/state", "running") + kv.AddInDB(db, "vpc/vpc-c/l3vni", "4002") + cmd := CreateVPCCommand{Name: "vpc-b", CIDR: "10.0.0.0/16", L3VNI: 4001} + if err := cmd.Prepare(db, bgpConfig()); err != nil { + t.Fatalf("Prepare a échoué : %v", err) + } +} diff --git a/internal/frr/client.go b/internal/frr/client.go new file mode 100644 index 0000000..d380e85 --- /dev/null +++ b/internal/frr/client.go @@ -0,0 +1,146 @@ +package frr + +import ( + "fmt" + "os/exec" + "strings" + "time" +) + +const ( + appliedWithNotes = "% Configuration applied with notes:" + l3vniStillBound = "% Please unconfigure l3vni" + l3vniRetries = 20 + l3vniRetryDelay = 250 * time.Millisecond +) + +type runner func(args ...string) ([]byte, error) + +type Client struct { + run runner + sleep func(time.Duration) +} + +func NewClient() *Client { + return &Client{ + run: func(args ...string) ([]byte, error) { + return exec.Command("vtysh", args...).CombinedOutput() + }, + sleep: time.Sleep, + } +} + +func (c *Client) ApplyBase(b Base) error { + if err := b.validate(); err != nil { + return err + } + running, err := c.runningConfig() + if err != nil { + return err + } + stale, err := b.staleReflectors(running) + if err != nil { + return err + } + if err := c.configure(b.commands()...); err != nil { + return err + } + if len(stale) > 0 { + cmds := []string{fmt.Sprintf("router bgp %d", b.ASN)} + for _, rr := range stale { + cmds = append(cmds, "no neighbor "+rr) + } + if err := c.configure(append(cmds, "exit")...); err != nil { + return err + } + } + return c.save() +} + +func (c *Client) ApplyVRF(v VRF) error { + if err := v.validate(); err != nil { + return err + } + if err := c.configure(v.commands()...); err != nil { + return err + } + return c.save() +} + +func (c *Client) WithdrawVRF(v VRF) error { + return c.teardown(v, routingTeardown) +} + +func (c *Client) RemoveVRF(v VRF) error { + if err := c.teardown(v, vrfTeardown); err != nil { + return err + } + running, err := c.runningConfig() + if err != nil { + return err + } + return remaining(routingTeardown(v, running)) +} + +func (c *Client) teardown(v VRF, plan func(VRF, string) []step) error { + if v.ID == "" { + return fmt.Errorf("frr: vrf id must not be empty") + } + running, err := c.runningConfig() + if err != nil { + return err + } + for _, s := range plan(v, running) { + if err := c.configureStep(s); err != nil { + return err + } + } + if err := c.save(); err != nil { + return err + } + if running, err = c.runningConfig(); err != nil { + return err + } + return remaining(plan(v, running)) +} + +func (c *Client) configureStep(s step) error { + err := c.configure(s...) + for i := 0; i < l3vniRetries && err != nil && strings.Contains(err.Error(), l3vniStillBound); i++ { + c.sleep(l3vniRetryDelay) + err = c.configure(s...) + } + return err +} + +func (c *Client) runningConfig() (string, error) { + return c.exec("show running-config") +} + +func (c *Client) configure(cmds ...string) error { + _, err := c.exec(append([]string{"configure terminal"}, cmds...)...) + return err +} + +func (c *Client) save() error { + _, err := c.exec("write memory") + return err +} + +func (c *Client) exec(cmds ...string) (string, error) { + args := make([]string, 0, 2*len(cmds)) + for _, cmd := range cmds { + args = append(args, "-c", cmd) + } + out, err := c.run(args...) + if err != nil { + return "", fmt.Errorf("vtysh %q: %w: %s", cmds, err, strings.TrimSpace(string(out))) + } + for _, l := range strings.Split(string(out), "\n") { + l = strings.TrimSpace(l) + if strings.HasPrefix(l, "%") && l != appliedWithNotes { + return "", fmt.Errorf("vtysh %q: %s", cmds, l) + } + } + return string(out), nil +} diff --git a/internal/frr/client_test.go b/internal/frr/client_test.go new file mode 100644 index 0000000..0f9ec9e --- /dev/null +++ b/internal/frr/client_test.go @@ -0,0 +1,321 @@ +package frr + +import ( + "errors" + "net" + "reflect" + "strings" + "testing" + "time" +) + +type fakeVtysh struct { + calls [][]string + running []string + fail map[string]string + status map[string]error + failTimes map[string]int + slept int +} + +func (f *fakeVtysh) run(args ...string) ([]byte, error) { + var cmds []string + for i := 1; i < len(args); i += 2 { + cmds = append(cmds, args[i]) + } + f.calls = append(f.calls, cmds) + last := cmds[len(cmds)-1] + if last == "show running-config" { + if len(f.running) == 0 { + return nil, errors.New("show running-config inattendu") + } + out := f.running[0] + f.running = f.running[1:] + return []byte(out), nil + } + for _, c := range cmds { + out, ok := f.fail[c] + if !ok { + continue + } + if n, limited := f.failTimes[c]; limited { + if n == 0 { + continue + } + f.failTimes[c] = n - 1 + } + return []byte(out), f.status[c] + } + return nil, nil +} + +func (f *fakeVtysh) client() *Client { + return &Client{run: f.run, sleep: func(time.Duration) { f.slept++ }} +} + +func (f *fakeVtysh) sent(cmd string) bool { + for _, c := range f.calls { + for _, x := range c { + if x == cmd { + return true + } + } + } + return false +} + +func TestApplyVRFConfiguresThenSaves(t *testing.T) { + f := &fakeVtysh{} + if err := f.client().ApplyVRF(labVRF(t)); err != nil { + t.Fatal(err) + } + want := [][]string{ + append([]string{"configure terminal"}, labVRF(t).commands()...), + {"write memory"}, + } + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels :\n%q\nattendu :\n%q", f.calls, want) + } +} + +func TestApplyVRFRefusesAnInvalidVRFWithoutCallingVtysh(t *testing.T) { + f := &fakeVtysh{} + v := labVRF(t) + v.L3VNI = 0 + if err := f.client().ApplyVRF(v); err == nil || !strings.Contains(err.Error(), "l3vni 0") { + t.Errorf("erreur %v", err) + } + if len(f.calls) != 0 { + t.Errorf("vtysh appelé : %q", f.calls) + } +} + +func TestExecReportsAnErrorPrintedByVtysh(t *testing.T) { + f := &fakeVtysh{fail: map[string]string{"vni 4001": "% Please unconfigure l3vni 4001\n"}} + err := f.client().ApplyVRF(labVRF(t)) + if err == nil || !strings.Contains(err.Error(), "% Please unconfigure l3vni 4001") { + t.Errorf("erreur %v", err) + } + if f.sent("write memory") { + t.Error("configuration sauvegardée malgré l'erreur") + } +} + +func TestExecReportsANonZeroExit(t *testing.T) { + f := &fakeVtysh{ + fail: map[string]string{"write memory": "Building Configuration...\n"}, + status: map[string]error{"write memory": errors.New("exit status 1")}, + } + err := f.client().ApplyVRF(labVRF(t)) + if err == nil || !strings.Contains(err.Error(), "exit status 1") || !strings.Contains(err.Error(), "Building Configuration...") { + t.Errorf("erreur %v", err) + } +} + +func TestWithdrawVRFRunsEachStepInOrderThenSaves(t *testing.T) { + f := &fakeVtysh{running: []string{fullRunning, otherOnlyRunning}} + if err := f.client().WithdrawVRF(labVRF(t)); err != nil { + t.Fatal(err) + } + want := [][]string{ + {"show running-config"}, + {"configure terminal", "router bgp 64600 vrf vrf-a1b2", "address-family ipv4 unicast", "no redistribute kernel"}, + {"configure terminal", "vrf vrf-a1b2", "no vni 4001"}, + {"configure terminal", "no router bgp 64600 vrf vrf-a1b2"}, + {"configure terminal", "no route-map EXPORT-a1b2"}, + {"configure terminal", "no ip prefix-list PL-a1b2"}, + {"write memory"}, + {"show running-config"}, + } + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels :\n%q\nattendu :\n%q", f.calls, want) + } +} + +func TestWithdrawVRFStopsAtTheFirstRefusedStep(t *testing.T) { + f := &fakeVtysh{ + running: []string{fullRunning}, + fail: map[string]string{"no vni 4001": "% Please unconfigure l3vni 4001\n"}, + } + if err := f.client().WithdrawVRF(labVRF(t)); err == nil || !strings.Contains(err.Error(), "Please unconfigure") { + t.Errorf("erreur %v", err) + } + if f.sent("no router bgp 64600 vrf vrf-a1b2") { + t.Error("instance BGP supprimée après un refus de l'étape précédente") + } +} + +func TestWithdrawVRFFailsWhenFRRKeptTheConfiguration(t *testing.T) { + f := &fakeVtysh{running: []string{fullRunning, fullRunning}} + err := f.client().WithdrawVRF(labVRF(t)) + if err == nil || !strings.Contains(err.Error(), "configuration still present after teardown") || !strings.Contains(err.Error(), "no router bgp 64600 vrf vrf-a1b2") { + t.Errorf("erreur %v", err) + } +} + +func TestRemoveVRFDeletesTheVRFAndChecksNothingIsLeft(t *testing.T) { + gone := "vrf vrf-a1b2c\n vni 4002\nexit-vrf\n" + f := &fakeVtysh{running: []string{otherOnlyRunning, gone, gone}} + if err := f.client().RemoveVRF(labVRF(t)); err != nil { + t.Fatal(err) + } + if !f.sent("no vrf vrf-a1b2") { + t.Errorf("appels : %q", f.calls) + } +} + +func TestRemoveVRFFailsWhenRoutingConfigurationIsStillThere(t *testing.T) { + f := &fakeVtysh{running: []string{otherOnlyRunning, "", fullRunning}} + err := f.client().RemoveVRF(labVRF(t)) + if err == nil || !strings.Contains(err.Error(), "configuration still present after teardown") { + t.Errorf("erreur %v", err) + } +} + +func TestTeardownNeedsOnlyTheID(t *testing.T) { + f := &fakeVtysh{running: []string{"", ""}} + if err := f.client().WithdrawVRF(VRF{ID: "a1b2"}); err != nil { + t.Errorf("démontage sans asn refusé : %v", err) + } + f = &fakeVtysh{} + if err := f.client().WithdrawVRF(VRF{ASN: 64600}); err == nil || len(f.calls) != 0 { + t.Errorf("démontage sans id : erreur %v, appels %q", err, f.calls) + } +} + +const baseRunning = `frr version 10.7.1 +router bgp 64600 + bgp router-id 192.168.14.13 + neighbor fabric peer-group + neighbor fabric remote-as 64600 + neighbor 10.255.255.1 peer-group fabric + neighbor 10.255.255.9 peer-group fabric + neighbor 10.0.0.5 peer-group monitoring + ! + address-family l2vpn evpn + neighbor fabric activate + advertise-all-vni + exit-address-family +exit +! +router bgp 64600 vrf vrf-a1b2 + neighbor 10.255.255.7 peer-group fabric +exit +` + +func labBase() Base { + return Base{ASN: 64600, RouterID: net.ParseIP("192.168.14.13"), RouteReflectors: []net.IP{net.ParseIP("10.255.255.1")}} +} + +func TestApplyBaseOnAFreshFRRConfiguresThenSaves(t *testing.T) { + f := &fakeVtysh{running: []string{""}} + if err := f.client().ApplyBase(labBase()); err != nil { + t.Fatal(err) + } + want := [][]string{ + {"show running-config"}, + append([]string{"configure terminal"}, labBase().commands()...), + {"write memory"}, + } + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels :\n%q\nattendu :\n%q", f.calls, want) + } +} + +func TestApplyBaseRemovesReflectorsNoLongerConfiguredAfterAddingTheNewOnes(t *testing.T) { + f := &fakeVtysh{running: []string{baseRunning}} + if err := f.client().ApplyBase(labBase()); err != nil { + t.Fatal(err) + } + want := [][]string{ + {"show running-config"}, + append([]string{"configure terminal"}, labBase().commands()...), + {"configure terminal", "router bgp 64600", "no neighbor 10.255.255.9", "exit"}, + {"write memory"}, + } + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels :\n%q\nattendu :\n%q", f.calls, want) + } +} + +func TestApplyBaseRefusesToChangeTheASN(t *testing.T) { + f := &fakeVtysh{running: []string{baseRunning}} + b := labBase() + b.ASN = 64601 + err := f.client().ApplyBase(b) + if err == nil || !strings.Contains(err.Error(), "bgp already runs as AS 64600, not 64601") { + t.Errorf("erreur %v", err) + } + if len(f.calls) != 1 { + t.Errorf("appels après le refus : %q", f.calls) + } +} + +func TestApplyBaseStopsWhenTheRunningConfigIsUnreadable(t *testing.T) { + f := &fakeVtysh{} + if err := f.client().ApplyBase(labBase()); err == nil { + t.Fatal("aucune erreur") + } + if f.sent("write memory") || f.sent("router bgp 64600") { + t.Errorf("appels : %q", f.calls) + } +} + +func TestExecAcceptsAConfigurationAppliedWithNotes(t *testing.T) { + f := &fakeVtysh{fail: map[string]string{"vni 4001": "% Configuration applied with notes:\nNo changes found to be committed!\n"}} + if err := f.client().ApplyVRF(labVRF(t)); err != nil { + t.Errorf("remarques prises pour une erreur : %v", err) + } +} + +func TestExecStillReportsOtherPercentLines(t *testing.T) { + f := &fakeVtysh{fail: map[string]string{"vni 4001": "% Configuration applied with notes:\n% Unknown command: vni 4001\n"}} + if err := f.client().ApplyVRF(labVRF(t)); err == nil || !strings.Contains(err.Error(), "% Unknown command") { + t.Errorf("erreur %v", err) + } +} + +func TestWithdrawVRFWaitsForBGPToReleaseTheL3VNI(t *testing.T) { + f := &fakeVtysh{ + running: []string{fullRunning, otherOnlyRunning}, + fail: map[string]string{"no router bgp 64600 vrf vrf-a1b2": "% Please unconfigure l3vni 4001\n"}, + status: map[string]error{"no router bgp 64600 vrf vrf-a1b2": errors.New("exit status 1")}, + failTimes: map[string]int{"no router bgp 64600 vrf vrf-a1b2": 3}, + } + if err := f.client().WithdrawVRF(labVRF(t)); err != nil { + t.Fatalf("refus transitoire non rattrapé : %v", err) + } + if f.slept != 3 { + t.Errorf("%d attentes, attendu 3", f.slept) + } + if !f.sent("no route-map EXPORT-a1b2") { + t.Errorf("démontage interrompu : %q", f.calls) + } +} + +func TestWithdrawVRFGivesUpOnAPersistentL3VNIRefusal(t *testing.T) { + f := &fakeVtysh{ + running: []string{fullRunning}, + fail: map[string]string{"no router bgp 64600 vrf vrf-a1b2": "% Please unconfigure l3vni 4001\n"}, + } + err := f.client().WithdrawVRF(labVRF(t)) + if err == nil || !strings.Contains(err.Error(), "Please unconfigure l3vni 4001") { + t.Fatalf("erreur %v", err) + } + if f.slept != l3vniRetries { + t.Errorf("%d attentes, attendu %d", f.slept, l3vniRetries) + } + if f.sent("no route-map EXPORT-a1b2") { + t.Error("étape suivante exécutée après l'abandon") + } +} + +func TestOtherTeardownErrorsAreNotRetried(t *testing.T) { + f := &fakeVtysh{ + running: []string{fullRunning}, + fail: map[string]string{"no router bgp 64600 vrf vrf-a1b2": "% Unknown command\n"}, + } + if err := f.client().WithdrawVRF(labVRF(t)); err == nil || f.slept != 0 { + t.Errorf("erreur %v, %d attentes", err, f.slept) + } +} diff --git a/internal/frr/config.go b/internal/frr/config.go new file mode 100644 index 0000000..34e3210 --- /dev/null +++ b/internal/frr/config.go @@ -0,0 +1,155 @@ +package frr + +import ( + "fmt" + "net" + "strings" +) + +const MaxL3VNI = 1<<16 - 1 + +type Base struct { + ASN uint32 + RouterID net.IP + RouteReflectors []net.IP +} + +type VRF struct { + ASN uint32 + ID string + L3VNI uint32 + VTEP net.IP + Supernet *net.IPNet +} + +func (b Base) validate() error { + if b.ASN == 0 { + return fmt.Errorf("frr: asn must not be 0") + } + if b.RouterID.To4() == nil { + return fmt.Errorf("frr: router-id %v is not an IPv4 address", b.RouterID) + } + if len(b.RouteReflectors) == 0 { + return fmt.Errorf("frr: at least one route reflector is required") + } + for _, rr := range b.RouteReflectors { + if rr.To4() == nil { + return fmt.Errorf("frr: route reflector %v is not an IPv4 address", rr) + } + } + return nil +} + +func (b Base) commands() []string { + cmds := []string{ + fmt.Sprintf("router bgp %d", b.ASN), + fmt.Sprintf("bgp router-id %s", b.RouterID), + "no bgp default ipv4-unicast", + "neighbor fabric peer-group", + fmt.Sprintf("neighbor fabric remote-as %d", b.ASN), + "neighbor fabric capability extended-nexthop", + } + for _, rr := range b.RouteReflectors { + cmds = append(cmds, fmt.Sprintf("neighbor %s peer-group fabric", rr)) + } + return append(cmds, + "address-family l2vpn evpn", + "neighbor fabric activate", + "advertise-all-vni", + "exit-address-family", + "exit", + ) +} + +func (b Base) staleReflectors(running string) ([]string, error) { + want := make(map[string]bool, len(b.RouteReflectors)) + for _, rr := range b.RouteReflectors { + want[rr.String()] = true + } + var stale []string + in := false + for _, l := range strings.Split(running, "\n") { + l = strings.TrimRight(l, " \r") + f := strings.Fields(l) + switch { + case len(f) == 3 && f[0] == "router" && f[1] == "bgp": + if f[2] != fmt.Sprint(b.ASN) { + return nil, fmt.Errorf("frr: bgp already runs as AS %s, not %d: changing the asn requires removing that instance by hand", f[2], b.ASN) + } + in = true + case in && l == "exit": + in = false + case in && len(f) == 4 && f[0] == "neighbor" && f[2] == "peer-group" && f[3] == "fabric" && !want[f[1]]: + stale = append(stale, f[1]) + } + } + return stale, nil +} + +func (v VRF) Name() string { + return "vrf-" + v.ID +} + +func (v VRF) prefixList() string { + return "PL-" + v.ID +} + +func (v VRF) routeMap() string { + return "EXPORT-" + v.ID +} + +func (v VRF) bgpInstance() string { + return fmt.Sprintf("router bgp %d vrf %s", v.ASN, v.Name()) +} + +func (v VRF) validateName() error { + if v.ASN == 0 { + return fmt.Errorf("frr: asn must not be 0") + } + if v.ID == "" { + return fmt.Errorf("frr: vrf id must not be empty") + } + return nil +} + +func (v VRF) validate() error { + if err := v.validateName(); err != nil { + return err + } + if v.L3VNI == 0 || v.L3VNI > MaxL3VNI { + return fmt.Errorf("frr: l3vni %d out of range 1-%d: the route distinguisher : holds 16 bits", v.L3VNI, MaxL3VNI) + } + if v.VTEP.To4() == nil { + return fmt.Errorf("frr: vtep %v is not an IPv4 address", v.VTEP) + } + if v.Supernet == nil || v.Supernet.IP.To4() == nil { + return fmt.Errorf("frr: supernet %v is not an IPv4 prefix", v.Supernet) + } + return nil +} + +func (v VRF) commands() []string { + return []string{ + fmt.Sprintf("ip prefix-list %s seq 10 permit %s le 32", v.prefixList(), v.Supernet), + fmt.Sprintf("route-map %s permit 10", v.routeMap()), + fmt.Sprintf("match ip address prefix-list %s", v.prefixList()), + "exit", + fmt.Sprintf("route-map %s deny 20", v.routeMap()), + "exit", + fmt.Sprintf("vrf %s", v.Name()), + fmt.Sprintf("vni %d", v.L3VNI), + "exit-vrf", + v.bgpInstance(), + fmt.Sprintf("bgp router-id %s", v.VTEP), + "no bgp default ipv4-unicast", + "address-family ipv4 unicast", + fmt.Sprintf("redistribute kernel route-map %s", v.routeMap()), + "exit-address-family", + "address-family l2vpn evpn", + fmt.Sprintf("rd %s:%d", v.VTEP, v.L3VNI), + fmt.Sprintf("route-target both %d:%d", v.ASN, v.L3VNI), + "advertise ipv4 unicast", + "exit-address-family", + "exit", + } +} diff --git a/internal/frr/config_test.go b/internal/frr/config_test.go new file mode 100644 index 0000000..766554a --- /dev/null +++ b/internal/frr/config_test.go @@ -0,0 +1,143 @@ +package frr + +import ( + "net" + "reflect" + "strings" + "testing" +) + +func mustCIDR(t *testing.T, s string) *net.IPNet { + t.Helper() + _, n, err := net.ParseCIDR(s) + if err != nil { + t.Fatal(err) + } + return n +} + +func labVRF(t *testing.T) VRF { + return VRF{ + ASN: 64600, + ID: "a1b2", + L3VNI: 4001, + VTEP: net.ParseIP("192.168.14.11"), + Supernet: mustCIDR(t, "10.10.0.0/16"), + } +} + +func TestBaseCommands(t *testing.T) { + b := Base{ + ASN: 64600, + RouterID: net.ParseIP("192.168.14.13"), + RouteReflectors: []net.IP{net.ParseIP("10.255.255.1"), net.ParseIP("10.255.255.2")}, + } + want := []string{ + "router bgp 64600", + "bgp router-id 192.168.14.13", + "no bgp default ipv4-unicast", + "neighbor fabric peer-group", + "neighbor fabric remote-as 64600", + "neighbor fabric capability extended-nexthop", + "neighbor 10.255.255.1 peer-group fabric", + "neighbor 10.255.255.2 peer-group fabric", + "address-family l2vpn evpn", + "neighbor fabric activate", + "advertise-all-vni", + "exit-address-family", + "exit", + } + if got := b.commands(); !reflect.DeepEqual(got, want) { + t.Errorf("commandes de base :\n%s\nattendu :\n%s", strings.Join(got, "\n"), strings.Join(want, "\n")) + } +} + +func TestVRFCommands(t *testing.T) { + want := []string{ + "ip prefix-list PL-a1b2 seq 10 permit 10.10.0.0/16 le 32", + "route-map EXPORT-a1b2 permit 10", + "match ip address prefix-list PL-a1b2", + "exit", + "route-map EXPORT-a1b2 deny 20", + "exit", + "vrf vrf-a1b2", + "vni 4001", + "exit-vrf", + "router bgp 64600 vrf vrf-a1b2", + "bgp router-id 192.168.14.11", + "no bgp default ipv4-unicast", + "address-family ipv4 unicast", + "redistribute kernel route-map EXPORT-a1b2", + "exit-address-family", + "address-family l2vpn evpn", + "rd 192.168.14.11:4001", + "route-target both 64600:4001", + "advertise ipv4 unicast", + "exit-address-family", + "exit", + } + if got := labVRF(t).commands(); !reflect.DeepEqual(got, want) { + t.Errorf("commandes de VRF :\n%s\nattendu :\n%s", strings.Join(got, "\n"), strings.Join(want, "\n")) + } +} + +func TestBaseValidateRejects(t *testing.T) { + valid := func() Base { + return Base{ASN: 64600, RouterID: net.ParseIP("192.168.14.13"), RouteReflectors: []net.IP{net.ParseIP("10.255.255.1")}} + } + if err := valid().validate(); err != nil { + t.Fatalf("base valide refusée : %v", err) + } + cases := map[string]struct { + mutate func(*Base) + msg string + }{ + "asn nul": {func(b *Base) { b.ASN = 0 }, "asn must not be 0"}, + "router-id absent": {func(b *Base) { b.RouterID = nil }, "router-id is not an IPv4 address"}, + "router-id IPv6": {func(b *Base) { b.RouterID = net.ParseIP("fd00::1") }, "router-id fd00::1 is not an IPv4 address"}, + "aucun RR": {func(b *Base) { b.RouteReflectors = nil }, "at least one route reflector is required"}, + "RR IPv6": {func(b *Base) { b.RouteReflectors = append(b.RouteReflectors, net.ParseIP("fd00::2")) }, "route reflector fd00::2 is not an IPv4 address"}, + } + for name, c := range cases { + b := valid() + c.mutate(&b) + if err := b.validate(); err == nil || !strings.Contains(err.Error(), c.msg) { + t.Errorf("%s : erreur %v, « %s » attendu", name, err, c.msg) + } + } +} + +func TestVRFValidateRejects(t *testing.T) { + if err := labVRF(t).validate(); err != nil { + t.Fatalf("VRF valide refusée : %v", err) + } + cases := map[string]struct { + mutate func(*VRF) + msg string + }{ + "asn nul": {func(v *VRF) { v.ASN = 0 }, "asn must not be 0"}, + "id vide": {func(v *VRF) { v.ID = "" }, "vrf id must not be empty"}, + "l3vni nul": {func(v *VRF) { v.L3VNI = 0 }, "l3vni 0 out of range 1-65535"}, + "l3vni sur 17 bits": {func(v *VRF) { v.L3VNI = 65536 }, "l3vni 65536 out of range 1-65535"}, + "l3vni sur 24 bits": {func(v *VRF) { v.L3VNI = 16777215 }, "l3vni 16777215 out of range 1-65535"}, + "vtep absent": {func(v *VRF) { v.VTEP = nil }, "vtep is not an IPv4 address"}, + "vtep IPv6": {func(v *VRF) { v.VTEP = net.ParseIP("fd00::1") }, "vtep fd00::1 is not an IPv4 address"}, + "supernet absent": {func(v *VRF) { v.Supernet = nil }, "supernet is not an IPv4 prefix"}, + "supernet IPv6": {func(v *VRF) { v.Supernet = mustCIDR(t, "fd00::/48") }, "supernet fd00::/48 is not an IPv4 prefix"}, + } + for name, c := range cases { + v := labVRF(t) + c.mutate(&v) + if err := v.validate(); err == nil || !strings.Contains(err.Error(), c.msg) { + t.Errorf("%s : erreur %v, « %s » attendu", name, err, c.msg) + } + } +} + +func TestVRFAcceptsTheLargest16BitVNI(t *testing.T) { + v := labVRF(t) + v.L3VNI = 65535 + if err := v.validate(); err != nil { + t.Errorf("l3vni 65535 refusée : %v", err) + } +} diff --git a/internal/frr/status.go b/internal/frr/status.go new file mode 100644 index 0000000..031ec39 --- /dev/null +++ b/internal/frr/status.go @@ -0,0 +1,49 @@ +package frr + +import ( + "fmt" + "net" + "strings" +) + +type VNIState struct { + Type string + State string + RouterMAC string +} + +func (c *Client) NeighborEstablished(peer net.IP) (bool, error) { + out, err := c.exec("show bgp neighbors " + peer.String()) + if err != nil { + return false, err + } + return strings.Contains(out, "BGP state = Established"), nil +} + +func (c *Client) VNI(vni uint32) (VNIState, error) { + out, err := c.exec(fmt.Sprintf("show evpn vni %d", vni)) + if err != nil { + return VNIState{}, err + } + return parseVNI(out), nil +} + +func parseVNI(out string) VNIState { + var s VNIState + for _, l := range strings.Split(out, "\n") { + key, value, ok := strings.Cut(strings.TrimSpace(l), ": ") + if !ok { + continue + } + value = strings.TrimSpace(value) + switch strings.ToLower(key) { + case "type": + s.Type = value + case "state": + s.State = value + case "router mac": + s.RouterMAC = strings.ToLower(value) + } + } + return s +} diff --git a/internal/frr/status_test.go b/internal/frr/status_test.go new file mode 100644 index 0000000..9b65f7d --- /dev/null +++ b/internal/frr/status_test.go @@ -0,0 +1,50 @@ +package frr + +import ( + "net" + "strings" + "testing" +) + +const vniOutput = `VNI: 2700 + Type: L3 + Tenant VRF: vrf-s7 + Vxlan-Intf: vxl3-s7 + SVI-If: brl3-s7 + State: Up + VNI Filter: none + System MAC: 02:02:c0:a8:0e:aa + Router MAC: 02:02:C0:A8:0E:0B + L2 VNIs: +` + +func TestVNIReadsTypeStateAndRouterMAC(t *testing.T) { + f := &fakeVtysh{fail: map[string]string{"show evpn vni 2700": vniOutput}} + s, err := f.client().VNI(2700) + if err != nil { + t.Fatal(err) + } + want := VNIState{Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:0b"} + if s != want { + t.Errorf("VNI = %+v, attendu %+v", s, want) + } +} + +func TestVNIReportsAnUnknownVNI(t *testing.T) { + f := &fakeVtysh{fail: map[string]string{"show evpn vni 9": "% VNI 9 does not exist\n"}} + if _, err := f.client().VNI(9); err == nil || !strings.Contains(err.Error(), "does not exist") { + t.Errorf("erreur %v", err) + } +} + +func TestNeighborEstablished(t *testing.T) { + rr := net.ParseIP("10.255.255.1") + f := &fakeVtysh{fail: map[string]string{"show bgp neighbors 10.255.255.1": "BGP neighbor is 10.255.255.1, remote AS 64600, local AS 64600, internal link\n BGP version 4, remote router ID 10.255.255.1\n BGP state = Established, up for 00:10:02\n"}} + if up, err := f.client().NeighborEstablished(rr); err != nil || !up { + t.Errorf("établie : %v, %v", up, err) + } + f = &fakeVtysh{fail: map[string]string{"show bgp neighbors 10.255.255.1": "BGP neighbor is 10.255.255.1\n BGP state = Active\n"}} + if up, err := f.client().NeighborEstablished(rr); err != nil || up { + t.Errorf("active : %v, %v", up, err) + } +} diff --git a/internal/frr/teardown.go b/internal/frr/teardown.go new file mode 100644 index 0000000..fcbc407 --- /dev/null +++ b/internal/frr/teardown.go @@ -0,0 +1,99 @@ +package frr + +import ( + "fmt" + "strconv" + "strings" +) + +type step []string + +func routingTeardown(v VRF, running string) []step { + lines := strings.Split(running, "\n") + instance := vrfInstance(lines, v.Name()) + bgp := instance != "" + var steps []step + if bgp { + steps = append(steps, step{instance, "address-family ipv4 unicast", "no redistribute kernel"}) + } + if vni := vrfVNI(lines, v.Name()); vni != "" { + steps = append(steps, step{"vrf " + v.Name(), "no vni " + vni}) + } + if bgp { + steps = append(steps, step{"no " + instance}) + } + if hasPrefix(lines, "route-map "+v.routeMap()+" ") { + steps = append(steps, step{"no route-map " + v.routeMap()}) + } + if hasPrefix(lines, "ip prefix-list "+v.prefixList()+" ") { + steps = append(steps, step{"no ip prefix-list " + v.prefixList()}) + } + return steps +} + +func vrfTeardown(v VRF, running string) []step { + if hasLine(strings.Split(running, "\n"), "vrf "+v.Name()) { + return []step{{"no vrf " + v.Name()}} + } + return nil +} + +func vrfInstance(lines []string, name string) string { + for _, l := range lines { + f := strings.Fields(l) + if len(f) != 5 || f[0] != "router" || f[1] != "bgp" || f[3] != "vrf" || f[4] != name { + continue + } + if _, err := strconv.ParseUint(f[2], 10, 32); err == nil { + return strings.Join(f, " ") + } + } + return "" +} + +func hasLine(lines []string, want string) bool { + for _, l := range lines { + if strings.TrimRight(l, " \r") == want { + return true + } + } + return false +} + +func hasPrefix(lines []string, prefix string) bool { + for _, l := range lines { + if strings.HasPrefix(l, prefix) { + return true + } + } + return false +} + +func vrfVNI(lines []string, name string) string { + in := false + for _, l := range lines { + l = strings.TrimRight(l, " \r") + switch { + case l == "vrf "+name: + in = true + case in && l == "exit-vrf": + return "" + case in: + if f := strings.Fields(l); len(f) >= 2 && f[0] == "vni" { + return f[1] + } + } + } + return "" +} + +func remaining(steps []step) error { + if len(steps) == 0 { + return nil + } + var parts []string + for _, s := range steps { + parts = append(parts, strings.Join(s, " / ")) + } + return fmt.Errorf("configuration still present after teardown: %s", strings.Join(parts, "; ")) +} diff --git a/internal/frr/teardown_test.go b/internal/frr/teardown_test.go new file mode 100644 index 0000000..210c943 --- /dev/null +++ b/internal/frr/teardown_test.go @@ -0,0 +1,159 @@ +package frr + +import ( + "reflect" + "testing" +) + +const fullRunning = `frr version 10.7.1 +frr defaults traditional +hostname hv1 +! +vrf vrf-a1b2 + vni 4001 +exit-vrf +! +vrf vrf-a1b2c + vni 4002 +exit-vrf +! +router bgp 64600 + bgp router-id 192.168.14.11 + no bgp default ipv4-unicast + neighbor fabric peer-group + neighbor fabric remote-as 64600 + neighbor 10.255.255.1 peer-group fabric + ! + address-family l2vpn evpn + neighbor fabric activate + advertise-all-vni + exit-address-family +exit +! +router bgp 64600 vrf vrf-a1b2 + bgp router-id 192.168.14.11 + no bgp default ipv4-unicast + ! + address-family ipv4 unicast + redistribute kernel route-map EXPORT-a1b2 + exit-address-family + ! + address-family l2vpn evpn + advertise ipv4 unicast + rd 192.168.14.11:4001 + route-target import 64600:4001 + route-target export 64600:4001 + exit-address-family +exit +! +router bgp 64600 vrf vrf-a1b2c + bgp router-id 192.168.14.11 +exit +! +ip prefix-list PL-a1b2 seq 10 permit 10.10.0.0/16 le 32 +ip prefix-list PL-a1b2c seq 10 permit 10.20.0.0/16 le 32 +! +route-map EXPORT-a1b2 permit 10 + match ip address prefix-list PL-a1b2 +exit +! +route-map EXPORT-a1b2 deny 20 +exit +! +route-map EXPORT-a1b2c permit 10 +exit +! +end +` + +const otherOnlyRunning = `vrf vrf-a1b2 +exit-vrf +! +vrf vrf-a1b2c + vni 4002 +exit-vrf +! +router bgp 64600 vrf vrf-a1b2c +exit +! +ip prefix-list PL-a1b2c seq 10 permit 10.20.0.0/16 le 32 +! +route-map EXPORT-a1b2c permit 10 +exit +! +end +` + +func TestRoutingTeardownFollowsTheOrderFRRRequires(t *testing.T) { + want := []step{ + {"router bgp 64600 vrf vrf-a1b2", "address-family ipv4 unicast", "no redistribute kernel"}, + {"vrf vrf-a1b2", "no vni 4001"}, + {"no router bgp 64600 vrf vrf-a1b2"}, + {"no route-map EXPORT-a1b2"}, + {"no ip prefix-list PL-a1b2"}, + } + if got := routingTeardown(labVRF(t), fullRunning); !reflect.DeepEqual(got, want) { + t.Errorf("démontage :\n%q\nattendu :\n%q", got, want) + } +} + +func TestRoutingTeardownTakesTheASNOfTheInstanceFromFRR(t *testing.T) { + want := []step{ + {"router bgp 64600 vrf vrf-a1b2", "address-family ipv4 unicast", "no redistribute kernel"}, + {"vrf vrf-a1b2", "no vni 4001"}, + {"no router bgp 64600 vrf vrf-a1b2"}, + {"no route-map EXPORT-a1b2"}, + {"no ip prefix-list PL-a1b2"}, + } + for _, asn := range []uint32{0, 64601} { + v := labVRF(t) + v.ASN = asn + if got := routingTeardown(v, fullRunning); !reflect.DeepEqual(got, want) { + t.Errorf("asn %d :\n%q\nattendu :\n%q", asn, got, want) + } + } +} + +func TestRoutingTeardownIgnoresAVRFWhoseNameExtendsOurs(t *testing.T) { + if got := routingTeardown(labVRF(t), otherOnlyRunning); got != nil { + t.Errorf("étapes visant vrf-a1b2c : %q", got) + } +} + +func TestRoutingTeardownUsesTheVNIFoundInFRR(t *testing.T) { + v := labVRF(t) + v.L3VNI = 9999 + running := "vrf vrf-a1b2\n vni 4001\nexit-vrf\n" + want := []step{{"vrf vrf-a1b2", "no vni 4001"}} + if got := routingTeardown(v, running); !reflect.DeepEqual(got, want) { + t.Errorf("démontage : %q, %q attendu", got, want) + } +} + +func TestRoutingTeardownSkipsWhatIsAbsent(t *testing.T) { + running := "vrf vrf-a1b2\n vni 4001\nexit-vrf\n!\nip prefix-list PL-a1b2 seq 10 permit 10.10.0.0/16 le 32\n" + want := []step{ + {"vrf vrf-a1b2", "no vni 4001"}, + {"no ip prefix-list PL-a1b2"}, + } + if got := routingTeardown(labVRF(t), running); !reflect.DeepEqual(got, want) { + t.Errorf("démontage :\n%q\nattendu :\n%q", got, want) + } +} + +func TestRoutingTeardownDoesNotReadAVNIOutsideTheVRFBlock(t *testing.T) { + running := "vrf vrf-a1b2\nexit-vrf\n!\nvrf vrf-a1b2c\n vni 4002\nexit-vrf\n" + if got := routingTeardown(labVRF(t), running); got != nil { + t.Errorf("étapes : %q", got) + } +} + +func TestVRFTeardown(t *testing.T) { + want := []step{{"no vrf vrf-a1b2"}} + if got := vrfTeardown(labVRF(t), otherOnlyRunning); !reflect.DeepEqual(got, want) { + t.Errorf("démontage : %q, %q attendu", got, want) + } + if got := vrfTeardown(labVRF(t), "vrf vrf-a1b2c\nexit-vrf\n"); got != nil { + t.Errorf("étapes visant vrf-a1b2c : %q", got) + } +} diff --git a/internal/l3vni/host.go b/internal/l3vni/host.go new file mode 100644 index 0000000..4899d3e --- /dev/null +++ b/internal/l3vni/host.go @@ -0,0 +1,94 @@ +package l3vni + +import ( + "net" + + "git.g3e.fr/syonad/two/internal/frr" + "git.g3e.fr/syonad/two/internal/netif" + "git.g3e.fr/syonad/two/internal/netns" + "git.g3e.fr/syonad/two/internal/sysctl" +) + +type host interface { + VTEPAddress(iface string) (net.IP, error) + Sysctl(ns, key, value string) error + CreateVRF(name string, table uint32) error + CreateBridge(name string, mtu int, mac net.HardwareAddr) error + SetMaster(iface, master string) error + CreateVxlan(name string, vni int, iface string, mtu int) error + CreateVeth(hostIf, nsIf, ns string, mtu int) error + AddrAdd(ns, iface string, prefix *net.IPNet) error + LinkUp(ns, iface string) error + RouteVia(ns string, dst *net.IPNet, gw net.IP, iface string) error + DeleteLink(name string) error + TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error + TableRouteDel(table uint32, dst *net.IPNet) error + ApplyVRF(v frr.VRF) error + WithdrawVRF(v frr.VRF) error + RemoveVRF(v frr.VRF) error +} + +type system struct { + frr *frr.Client +} + +func newSystem() system { + return system{frr: frr.NewClient()} +} + +func in(ns string, fn func() error) error { + if ns == "" { + return fn() + } + return netns.Call(ns, fn) +} + +func (system) VTEPAddress(iface string) (net.IP, error) { return netif.VTEPAddress(iface) } + +func (system) Sysctl(ns, key, value string) error { + return in(ns, func() error { return sysctl.Set(key, value) }) +} + +func (system) CreateVRF(name string, table uint32) error { return netif.CreateVRF(name, table) } + +func (system) CreateBridge(name string, mtu int, mac net.HardwareAddr) error { + return netif.CreateBridge(name, mtu, mac) +} + +func (system) SetMaster(iface, master string) error { return netif.BridgeSetMaster(iface, master) } + +func (system) CreateVxlan(name string, vni int, iface string, mtu int) error { + return netif.CreateVxlan(name, vni, iface, mtu) +} + +func (system) CreateVeth(hostIf, nsIf, ns string, mtu int) error { + return netif.CreateVethToNetns(hostIf, nsIf, "/var/run/netns/"+ns, mtu) +} + +func (system) AddrAdd(ns, iface string, prefix *net.IPNet) error { + return in(ns, func() error { return netif.AddrAddPrefix(iface, prefix) }) +} + +func (system) LinkUp(ns, iface string) error { + return in(ns, func() error { return netif.LinkSetUp(iface) }) +} + +func (system) RouteVia(ns string, dst *net.IPNet, gw net.IP, iface string) error { + return in(ns, func() error { return netif.RouteReplaceVia(0, dst, gw, iface) }) +} + +func (system) DeleteLink(name string) error { return netif.DeleteLinkIfExists(name) } + +func (system) TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error { + return netif.RouteReplaceVia(int(table), dst, gw, iface) +} + +func (system) TableRouteDel(table uint32, dst *net.IPNet) error { + return netif.RouteDelIfExists(int(table), dst) +} + +func (s system) ApplyVRF(v frr.VRF) error { return s.frr.ApplyVRF(v) } + +func (s system) WithdrawVRF(v frr.VRF) error { return s.frr.WithdrawVRF(v) } + +func (s system) RemoveVRF(v frr.VRF) error { return s.frr.RemoveVRF(v) } diff --git a/internal/l3vni/l3.go b/internal/l3vni/l3.go new file mode 100644 index 0000000..3558274 --- /dev/null +++ b/internal/l3vni/l3.go @@ -0,0 +1,177 @@ +package l3vni + +import ( + "errors" + "fmt" + "net" + "strconv" + + configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/frr" + "git.g3e.fr/syonad/two/internal/netif" + "git.g3e.fr/syonad/two/pkg/db/kv" + + "github.com/dgraph-io/badger/v4" +) + +const l3MTU = 1500 + +var ( + transitHost = &net.IPNet{IP: net.IPv4(169, 254, 0, 1).To4(), Mask: net.CIDRMask(30, 32)} + transitNetns = &net.IPNet{IP: net.IPv4(169, 254, 0, 2).To4(), Mask: net.CIDRMask(30, 32)} +) + +type l3VPC struct { + netns string + id string + vni uint32 + supernet *net.IPNet +} + +func loadL3(db *badger.DB, name, id string) (l3VPC, bool, error) { + raw, err := kv.GetFromDB(db, "vpc/"+name+"/l3vni") + if errors.Is(err, badger.ErrKeyNotFound) { + return l3VPC{}, false, nil + } + if err != nil { + return l3VPC{}, false, fmt.Errorf("vpc %q: reading l3vni: %w", name, err) + } + vni, err := strconv.ParseUint(raw, 10, 32) + if err != nil { + return l3VPC{}, false, fmt.Errorf("vpc %q: invalid l3vni %q", name, raw) + } + if err := Valid(uint32(vni)); err != nil { + return l3VPC{}, false, fmt.Errorf("vpc %q: %w", name, err) + } + cidr, err := kv.GetFromDB(db, "vpc/"+name+"/cidr") + if err != nil { + return l3VPC{}, false, fmt.Errorf("vpc %q: no cidr: %w", name, err) + } + _, supernet, err := net.ParseCIDR(cidr) + if err != nil { + return l3VPC{}, false, fmt.Errorf("vpc %q: invalid cidr %q: %w", name, cidr, err) + } + return l3VPC{netns: name, id: id, vni: uint32(vni), supernet: supernet}, true, nil +} + +func (v l3VPC) vrf() string { return "vrf-" + v.id } +func (v l3VPC) bridge() string { return "brl3-" + v.id } +func (v l3VPC) vxlan() string { return "vxl3-" + v.id } +func (v l3VPC) vethHost() string { return "l3-" + v.id + "-o" } +func (v l3VPC) vethNetns() string { return "l3-" + v.id + "-i" } + +func bgpASN(cfg *configuration.Config) (uint32, error) { + if cfg == nil || !cfg.BGP.Enabled() { + return 0, fmt.Errorf("the vpc has an l3vni but the agent configuration has no bgp section") + } + return cfg.BGP.ASN, nil +} + +func createL3(h host, cfg *configuration.Config, v l3VPC) error { + asn, err := bgpASN(cfg) + if err != nil { + return err + } + vtep, err := h.VTEPAddress(cfg.DefaultInterface) + if err != nil { + return fmt.Errorf("vtep: %w", err) + } + rmac, err := RouterMAC(vtep) + if err != nil { + return err + } + steps := []struct { + what string + run func() error + }{ + {"create " + v.vrf(), func() error { return h.CreateVRF(v.vrf(), v.vni) }}, + {"create " + v.bridge(), func() error { return h.CreateBridge(v.bridge(), l3MTU, rmac) }}, + {"attach " + v.bridge(), func() error { return h.SetMaster(v.bridge(), v.vrf()) }}, + {"create " + v.vxlan(), func() error { return h.CreateVxlan(v.vxlan(), int(v.vni), cfg.DefaultInterface, l3MTU) }}, + {"attach " + v.vxlan(), func() error { return h.SetMaster(v.vxlan(), v.bridge()) }}, + {"set up " + v.vxlan(), func() error { return h.LinkUp("", v.vxlan()) }}, + {"create " + v.vethHost(), func() error { return h.CreateVeth(v.vethHost(), v.vethNetns(), v.netns, l3MTU) }}, + {"attach " + v.vethHost(), func() error { return h.SetMaster(v.vethHost(), v.vrf()) }}, + {"address " + v.vethHost(), func() error { return h.AddrAdd("", v.vethHost(), transitHost) }}, + {"set up " + v.vethHost(), func() error { return h.LinkUp("", v.vethHost()) }}, + {"forwarding on " + v.bridge(), func() error { return h.Sysctl("", "net.ipv4.conf."+v.bridge()+".forwarding", "1") }}, + {"forwarding on " + v.vethHost(), func() error { return h.Sysctl("", "net.ipv4.conf."+v.vethHost()+".forwarding", "1") }}, + {"address " + v.vethNetns(), func() error { return h.AddrAdd(v.netns, v.vethNetns(), transitNetns) }}, + {"set up " + v.vethNetns(), func() error { return h.LinkUp(v.netns, v.vethNetns()) }}, + {"forwarding in " + v.netns, func() error { return h.Sysctl(v.netns, "net.ipv4.ip_forward", "1") }}, + {"route " + v.supernet.String() + " in " + v.netns, func() error { + return h.RouteVia(v.netns, v.supernet, transitHost.IP, v.vethNetns()) + }}, + {"frr " + v.vrf(), func() error { + return h.ApplyVRF(frr.VRF{ASN: asn, ID: v.id, L3VNI: v.vni, VTEP: vtep, Supernet: v.supernet}) + }}, + } + for _, s := range steps { + if err := s.run(); err != nil { + return fmt.Errorf("l3vni %d: %s: %w", v.vni, s.what, err) + } + } + return nil +} + +func deleteL3(h host, v l3VPC) error { + frrVRF := frr.VRF{ID: v.id} + if err := h.WithdrawVRF(frrVRF); err != nil { + return fmt.Errorf("l3vni %d: withdraw frr: %w", v.vni, err) + } + for _, link := range []string{v.vethHost(), v.vxlan(), v.bridge(), v.vrf()} { + if err := h.DeleteLink(link); err != nil { + return fmt.Errorf("l3vni %d: delete %s: %w", v.vni, link, err) + } + } + if err := h.RemoveVRF(frrVRF); err != nil { + return fmt.Errorf("l3vni %d: remove frr vrf: %w", v.vni, err) + } + return nil +} + +func Create(db *badger.DB, vpcName string, cfg *configuration.Config) error { + v, ok, err := loadRouted(db, vpcName) + if err != nil || !ok { + return err + } + return createL3(newSystem(), cfg, v) +} + +func Delete(db *badger.DB, vpcName string) error { + v, ok, err := loadRouted(db, vpcName) + if err != nil || !ok { + return err + } + return deleteL3(newSystem(), v) +} + +type Routing struct { + VNI uint32 + Supernet *net.IPNet + VRF string + Bridge string + Vxlan string + VethHost string + VethNetns string +} + +func LoadRouting(db *badger.DB, vpcName string) (Routing, bool, error) { + v, ok, err := loadRouted(db, vpcName) + if err != nil || !ok { + return Routing{}, ok, err + } + return Routing{ + VNI: v.vni, + Supernet: v.supernet, + VRF: v.vrf(), + Bridge: v.bridge(), + Vxlan: v.vxlan(), + VethHost: v.vethHost(), + VethNetns: v.vethNetns(), + }, true, nil +} + +func RouterMAC(vtep net.IP) (net.HardwareAddr, error) { + return netif.HostMAC(netif.RoleRouter, vtep) +} diff --git a/internal/l3vni/l3_test.go b/internal/l3vni/l3_test.go new file mode 100644 index 0000000..ee3f9bc --- /dev/null +++ b/internal/l3vni/l3_test.go @@ -0,0 +1,260 @@ +package l3vni + +import ( + "errors" + "fmt" + "net" + "reflect" + "strings" + "testing" + + configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/frr" + "git.g3e.fr/syonad/two/pkg/db/kv" +) + +type fakeHost struct { + calls []string + fail map[string]error +} + +func (f *fakeHost) record(call string) error { + f.calls = append(f.calls, call) + for prefix, err := range f.fail { + if strings.HasPrefix(call, prefix) { + return err + } + } + return nil +} + +func (f *fakeHost) VTEPAddress(iface string) (net.IP, error) { + if err := f.record("vtep " + iface); err != nil { + return nil, err + } + return net.ParseIP("192.168.14.11"), nil +} + +func (f *fakeHost) Sysctl(ns, key, value string) error { + return f.record(fmt.Sprintf("sysctl [%s] %s=%s", ns, key, value)) +} + +func (f *fakeHost) CreateVRF(name string, table uint32) error { + return f.record(fmt.Sprintf("vrf %s table %d", name, table)) +} + +func (f *fakeHost) CreateBridge(name string, mtu int, mac net.HardwareAddr) error { + return f.record(fmt.Sprintf("bridge %s mtu %d mac %s", name, mtu, mac)) +} + +func (f *fakeHost) SetMaster(iface, master string) error { + return f.record(fmt.Sprintf("master %s %s", iface, master)) +} + +func (f *fakeHost) CreateVxlan(name string, vni int, iface string, mtu int) error { + return f.record(fmt.Sprintf("vxlan %s id %d dev %s mtu %d", name, vni, iface, mtu)) +} + +func (f *fakeHost) CreateVeth(hostIf, nsIf, ns string, mtu int) error { + return f.record(fmt.Sprintf("veth %s peer %s netns %s mtu %d", hostIf, nsIf, ns, mtu)) +} + +func (f *fakeHost) AddrAdd(ns, iface string, prefix *net.IPNet) error { + return f.record(fmt.Sprintf("addr [%s] %s %s", ns, iface, prefix)) +} + +func (f *fakeHost) LinkUp(ns, iface string) error { + return f.record(fmt.Sprintf("up [%s] %s", ns, iface)) +} + +func (f *fakeHost) RouteVia(ns string, dst *net.IPNet, gw net.IP, iface string) error { + return f.record(fmt.Sprintf("route [%s] %s via %s dev %s", ns, dst, gw, iface)) +} + +func (f *fakeHost) DeleteLink(name string) error { + return f.record("del " + name) +} + +func (f *fakeHost) TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error { + return f.record(fmt.Sprintf("table %d route %s via %s dev %s", table, dst, gw, iface)) +} + +func (f *fakeHost) TableRouteDel(table uint32, dst *net.IPNet) error { + return f.record(fmt.Sprintf("table %d del %s", table, dst)) +} + +func (f *fakeHost) ApplyVRF(v frr.VRF) error { + return f.record(fmt.Sprintf("frr apply asn=%d id=%s vni=%d vtep=%s supernet=%s", v.ASN, v.ID, v.L3VNI, v.VTEP, v.Supernet)) +} + +func (f *fakeHost) WithdrawVRF(v frr.VRF) error { + return f.record(fmt.Sprintf("frr withdraw asn=%d id=%s vni=%d", v.ASN, v.ID, v.L3VNI)) +} + +func (f *fakeHost) RemoveVRF(v frr.VRF) error { + return f.record(fmt.Sprintf("frr remove asn=%d id=%s vni=%d", v.ASN, v.ID, v.L3VNI)) +} + +func bgpConfig() *configuration.Config { + cfg := &configuration.Config{DefaultInterface: "br-000000"} + cfg.BGP.ASN = 64600 + cfg.BGP.RouteReflectors = []string{"10.255.255.1"} + return cfg +} + +func labL3(t *testing.T) l3VPC { + t.Helper() + _, supernet, err := net.ParseCIDR("10.241.0.0/16") + if err != nil { + t.Fatal(err) + } + return l3VPC{netns: "vp-s7", id: "s7", vni: 2700, supernet: supernet} +} + +func TestCreateL3FollowsTheLabRecipe(t *testing.T) { + f := &fakeHost{} + if err := createL3(f, bgpConfig(), labL3(t)); err != nil { + t.Fatal(err) + } + want := []string{ + "vtep br-000000", + "vrf vrf-s7 table 2700", + "bridge brl3-s7 mtu 1500 mac 02:02:c0:a8:0e:0b", + "master brl3-s7 vrf-s7", + "vxlan vxl3-s7 id 2700 dev br-000000 mtu 1500", + "master vxl3-s7 brl3-s7", + "up [] vxl3-s7", + "veth l3-s7-o peer l3-s7-i netns vp-s7 mtu 1500", + "master l3-s7-o vrf-s7", + "addr [] l3-s7-o 169.254.0.1/30", + "up [] l3-s7-o", + "sysctl [] net.ipv4.conf.brl3-s7.forwarding=1", + "sysctl [] net.ipv4.conf.l3-s7-o.forwarding=1", + "addr [vp-s7] l3-s7-i 169.254.0.2/30", + "up [vp-s7] l3-s7-i", + "sysctl [vp-s7] net.ipv4.ip_forward=1", + "route [vp-s7] 10.241.0.0/16 via 169.254.0.1 dev l3-s7-i", + "frr apply asn=64600 id=s7 vni=2700 vtep=192.168.14.11 supernet=10.241.0.0/16", + } + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels :\n%s\nattendu :\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n")) + } +} + +func TestCreateL3RequiresTheBGPSectionBeforeTouchingTheHost(t *testing.T) { + f := &fakeHost{} + cfg := &configuration.Config{DefaultInterface: "br-000000"} + if err := createL3(f, cfg, labL3(t)); err == nil || !strings.Contains(err.Error(), "no bgp section") { + t.Errorf("erreur %v", err) + } + if err := createL3(f, nil, labL3(t)); err == nil { + t.Error("config absente acceptée") + } + if len(f.calls) != 0 { + t.Errorf("appels : %q", f.calls) + } +} + +func TestCreateL3StopsAtTheFirstFailure(t *testing.T) { + f := &fakeHost{fail: map[string]error{"vxlan ": errors.New("file exists")}} + err := createL3(f, bgpConfig(), labL3(t)) + if err == nil || !strings.Contains(err.Error(), "l3vni 2700: create vxl3-s7: file exists") { + t.Errorf("erreur %v", err) + } + if last := f.calls[len(f.calls)-1]; !strings.HasPrefix(last, "vxlan ") { + t.Errorf("appels après l'échec : %q", f.calls) + } +} + +func TestDeleteL3WithdrawsFRRThenTheKernelThenTheVRF(t *testing.T) { + f := &fakeHost{} + if err := deleteL3(f, labL3(t)); err != nil { + t.Fatal(err) + } + want := []string{ + "frr withdraw asn=0 id=s7 vni=0", + "del l3-s7-o", + "del vxl3-s7", + "del brl3-s7", + "del vrf-s7", + "frr remove asn=0 id=s7 vni=0", + } + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels :\n%s\nattendu :\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n")) + } +} + +func TestDeleteL3KeepsTheKernelWhenFRRRefusesTheWithdrawal(t *testing.T) { + f := &fakeHost{fail: map[string]error{"frr withdraw": errors.New("% Please unconfigure l3vni 2700")}} + err := deleteL3(f, labL3(t)) + if err == nil || !strings.Contains(err.Error(), "withdraw frr") { + t.Errorf("erreur %v", err) + } + if len(f.calls) != 1 { + t.Errorf("le noyau a été touché malgré le refus de FRR : %q", f.calls) + } +} + +func TestDeleteL3KeepsTheFRRVRFWhenAKernelLinkCannotBeDeleted(t *testing.T) { + f := &fakeHost{fail: map[string]error{"del brl3-s7": errors.New("device busy")}} + if err := deleteL3(f, labL3(t)); err == nil || !strings.Contains(err.Error(), "delete brl3-s7") { + t.Errorf("erreur %v", err) + } + for _, c := range f.calls { + if strings.HasPrefix(c, "frr remove") || c == "del vrf-s7" { + t.Errorf("étape exécutée après l'échec : %q", f.calls) + } + } +} + +func TestDeleteL3DoesNotDependOnTheAgentBGPSection(t *testing.T) { + f := &fakeHost{} + if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 6 { + t.Errorf("erreur %v, appels %q", err, f.calls) + } +} + +func TestRouterMAC(t *testing.T) { + mac, err := RouterMAC(net.ParseIP("192.168.14.11")) + if err != nil || mac.String() != "02:02:c0:a8:0e:0b" { + t.Errorf("RouterMAC = %v, %v", mac, err) + } + if _, err := RouterMAC(net.ParseIP("fd00::1")); err == nil { + t.Error("VTEP IPv6 accepté") + } +} + +func TestLoadL3(t *testing.T) { + db := kv.InitDB(kv.Config{Path: t.TempDir()}, false) + t.Cleanup(func() { db.Close() }) + kv.AddInDB(db, "vpc/vp-a/cidr", "10.241.0.0/16") + if _, ok, err := loadL3(db, "vp-a", "a"); ok || err != nil { + t.Errorf("VPC sans l3vni : ok=%v err=%v", ok, err) + } + kv.AddInDB(db, "vpc/vp-a/l3vni", "2700") + got, ok, err := loadL3(db, "vp-a", "a") + if !ok || err != nil || got.vni != 2700 || got.id != "a" || got.netns != "vp-a" || got.supernet.String() != "10.241.0.0/16" { + t.Errorf("loadL3 = %+v, %v, %v", got, ok, err) + } + for _, bad := range []string{"abc", "254", "0"} { + kv.AddInDB(db, "vpc/vp-a/l3vni", bad) + if _, _, err := loadL3(db, "vp-a", "a"); err == nil { + t.Errorf("l3vni %q acceptée", bad) + } + } + kv.AddInDB(db, "vpc/vp-b/l3vni", "2700") + if _, _, err := loadL3(db, "vp-b", "b"); err == nil || !strings.Contains(err.Error(), "no cidr") { + t.Errorf("VPC sans cidr : %v", err) + } +} + +func TestLoadL3ReportsAReadErrorInsteadOfAVPCWithoutL3VNI(t *testing.T) { + db := kv.InitDB(kv.Config{Path: t.TempDir()}, false) + kv.AddInDB(db, "vpc/vp-a/cidr", "10.241.0.0/16") + kv.AddInDB(db, "vpc/vp-a/l3vni", "2700") + db.Close() + _, ok, err := loadL3(db, "vp-a", "a") + if ok || err == nil || !strings.Contains(err.Error(), "reading l3vni") { + t.Errorf("base fermée : ok=%v err=%v, erreur de lecture attendue", ok, err) + } +} diff --git a/internal/l3vni/l3vni.go b/internal/l3vni/l3vni.go new file mode 100644 index 0000000..bebfa7b --- /dev/null +++ b/internal/l3vni/l3vni.go @@ -0,0 +1,17 @@ +package l3vni + +import ( + "fmt" + + "git.g3e.fr/syonad/two/internal/frr" +) + +func Valid(id uint32) error { + if id == 0 || id > frr.MaxL3VNI { + return fmt.Errorf("l3vni %d out of range 1-%d: the route distinguisher : holds 16 bits", id, frr.MaxL3VNI) + } + if id >= 253 && id <= 255 { + return fmt.Errorf("l3vni %d is reserved: it is also the routing table id, and tables 253-255 belong to the kernel", id) + } + return nil +} diff --git a/internal/l3vni/l3vni_test.go b/internal/l3vni/l3vni_test.go new file mode 100644 index 0000000..ea18bc3 --- /dev/null +++ b/internal/l3vni/l3vni_test.go @@ -0,0 +1,30 @@ +package l3vni + +import ( + "strings" + "testing" +) + +func TestValid_AcceptsEvery16BitValueOutsideTheKernelTables(t *testing.T) { + for _, id := range []uint32{1, 252, 256, 4001, 65535} { + if err := Valid(id); err != nil { + t.Errorf("Valid(%d) = %v", id, err) + } + } +} + +func TestValid_RejectsOutOfRangeAndReservedTables(t *testing.T) { + cases := map[uint32]string{ + 0: "out of range 1-65535", + 65536: "out of range 1-65535", + 16777215: "out of range 1-65535", + 253: "is reserved", + 254: "is reserved", + 255: "is reserved", + } + for id, want := range cases { + if err := Valid(id); err == nil || !strings.Contains(err.Error(), want) { + t.Errorf("Valid(%d) = %v, attendu %q", id, err, want) + } + } +} diff --git a/internal/l3vni/route.go b/internal/l3vni/route.go new file mode 100644 index 0000000..333abf6 --- /dev/null +++ b/internal/l3vni/route.go @@ -0,0 +1,50 @@ +package l3vni + +import ( + "fmt" + "net" + "strings" + + "github.com/dgraph-io/badger/v4" +) + +func ExportRoute(db *badger.DB, vpcName string, dst *net.IPNet) error { + return exportRoute(newSystem(), db, vpcName, dst) +} + +func WithdrawRoute(db *badger.DB, vpcName string, dst *net.IPNet) error { + return withdrawRoute(newSystem(), db, vpcName, dst) +} + +func loadRouted(db *badger.DB, vpcName string) (l3VPC, bool, error) { + parts := strings.SplitN(vpcName, "-", 2) + if len(parts) != 2 { + return l3VPC{}, false, fmt.Errorf("invalid vpc name %q", vpcName) + } + return loadL3(db, vpcName, parts[1]) +} + +func exportRoute(h host, db *badger.DB, vpcName string, dst *net.IPNet) error { + v, ok, err := loadRouted(db, vpcName) + if err != nil || !ok { + return err + } + if !v.supernet.Contains(dst.IP) { + return fmt.Errorf("vpc %q: %s is outside %s", vpcName, dst, v.supernet) + } + if err := h.TableRouteVia(v.vni, dst, transitNetns.IP, v.vethHost()); err != nil { + return fmt.Errorf("export %s in %s: %w", dst, v.vrf(), err) + } + return nil +} + +func withdrawRoute(h host, db *badger.DB, vpcName string, dst *net.IPNet) error { + v, ok, err := loadRouted(db, vpcName) + if err != nil || !ok { + return err + } + if err := h.TableRouteDel(v.vni, dst); err != nil { + return fmt.Errorf("withdraw %s from %s: %w", dst, v.vrf(), err) + } + return nil +} diff --git a/internal/l3vni/route_test.go b/internal/l3vni/route_test.go new file mode 100644 index 0000000..0377f68 --- /dev/null +++ b/internal/l3vni/route_test.go @@ -0,0 +1,89 @@ +package l3vni + +import ( + "errors" + "net" + "reflect" + "strings" + "testing" + + "git.g3e.fr/syonad/two/pkg/db/kv" + "github.com/dgraph-io/badger/v4" +) + +func routedDB(t *testing.T) *badger.DB { + t.Helper() + db := kv.InitDB(kv.Config{Path: t.TempDir()}, false) + t.Cleanup(func() { db.Close() }) + kv.AddInDB(db, "vpc/vp-s7/cidr", "10.241.0.0/16") + kv.AddInDB(db, "vpc/vp-s7/l3vni", "2700") + kv.AddInDB(db, "vpc/vp-flat/cidr", "10.242.0.0/16") + return db +} + +func cidr(t *testing.T, s string) *net.IPNet { + t.Helper() + _, n, err := net.ParseCIDR(s) + if err != nil { + t.Fatal(err) + } + return n +} + +func TestExportRouteInstallsTheRouteInTheVRFTowardsTheNetns(t *testing.T) { + f := &fakeHost{} + if err := exportRoute(f, routedDB(t), "vp-s7", cidr(t, "10.241.1.0/24")); err != nil { + t.Fatal(err) + } + want := []string{"table 2700 route 10.241.1.0/24 via 169.254.0.2 dev l3-s7-o"} + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels %q, attendu %q", f.calls, want) + } +} + +func TestExportRouteRefusesAPrefixOutsideTheVPC(t *testing.T) { + f := &fakeHost{} + err := exportRoute(f, routedDB(t), "vp-s7", cidr(t, "10.99.1.0/24")) + if err == nil || !strings.Contains(err.Error(), "outside 10.241.0.0/16") || len(f.calls) != 0 { + t.Errorf("erreur %v, appels %q", err, f.calls) + } +} + +func TestWithdrawRouteDeletesFromTheVRFTable(t *testing.T) { + f := &fakeHost{} + if err := withdrawRoute(f, routedDB(t), "vp-s7", cidr(t, "10.241.1.10/32")); err != nil { + t.Fatal(err) + } + want := []string{"table 2700 del 10.241.1.10/32"} + if !reflect.DeepEqual(f.calls, want) { + t.Errorf("appels %q, attendu %q", f.calls, want) + } +} + +func TestRoutesAreIgnoredForAVPCWithoutL3VNI(t *testing.T) { + f := &fakeHost{} + db := routedDB(t) + if err := exportRoute(f, db, "vp-flat", cidr(t, "10.242.1.0/24")); err != nil { + t.Error(err) + } + if err := withdrawRoute(f, db, "vp-flat", cidr(t, "10.242.1.0/24")); err != nil { + t.Error(err) + } + if len(f.calls) != 0 { + t.Errorf("appels %q", f.calls) + } +} + +func TestRouteErrorsArePropagated(t *testing.T) { + db := routedDB(t) + f := &fakeHost{fail: map[string]error{"table ": errors.New("network unreachable")}} + if err := exportRoute(f, db, "vp-s7", cidr(t, "10.241.1.0/24")); err == nil || !strings.Contains(err.Error(), "export 10.241.1.0/24 in vrf-s7") { + t.Errorf("export : %v", err) + } + if err := withdrawRoute(f, db, "vp-s7", cidr(t, "10.241.1.0/24")); err == nil || !strings.Contains(err.Error(), "withdraw 10.241.1.0/24 from vrf-s7") { + t.Errorf("withdraw : %v", err) + } + if err := exportRoute(f, db, "novpc", cidr(t, "10.241.1.0/24")); err == nil { + t.Error("nom de VPC sans tiret accepté") + } +} diff --git a/internal/lab/render/roles_test.go b/internal/lab/render/roles_test.go index fd0e0de..c62a805 100644 --- a/internal/lab/render/roles_test.go +++ b/internal/lab/render/roles_test.go @@ -147,7 +147,7 @@ func TestRoles_ProvisioningIsOneScriptThatStopsAtTheFirstFailure(t *testing.T) { nodes := renderRoles(t) 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": "/usr/local/sbin/lab-deploy\n/usr/local/sbin/lab-frr\n", + "hv1": "/usr/local/sbin/lab-deploy\n/usr/local/sbin/lab-frr\nsystemctl restart agent.service\n", "hv2": "/usr/local/sbin/lab-deploy\n", } { cfg := user(t, nodeNamed(t, nodes, name)) diff --git a/internal/lab/render/seed.go b/internal/lab/render/seed.go index 0255140..34ef572 100644 --- a/internal/lab/render/seed.go +++ b/internal/lab/render/seed.go @@ -133,6 +133,9 @@ func userData(p *topology.Plan, n topology.NodePlan, o Options) ([]byte, error) writeFile{Path: FRRScript, Permissions: "0755", Content: frrScript(n)}, ) steps = append(steps, FRRScript) + if n.Role == topology.RoleHypervisor { + steps = append(steps, "systemctl restart agent.service") + } } if len(steps) > 0 { cfg.WriteFiles = append(cfg.WriteFiles, diff --git a/internal/netif/addr.go b/internal/netif/addr.go index b45b6aa..cd5dd74 100644 --- a/internal/netif/addr.go +++ b/internal/netif/addr.go @@ -19,3 +19,11 @@ func AddrAdd(iface string, ip net.IP) error { } return netlink.AddrAdd(link, addr) } + +func AddrAddPrefix(iface string, prefix *net.IPNet) error { + link, err := netlink.LinkByName(iface) + if err != nil { + return err + } + return netlink.AddrAdd(link, &netlink.Addr{IPNet: prefix}) +} diff --git a/internal/netif/bridge.go b/internal/netif/bridge.go index a4754a3..1bd5e18 100644 --- a/internal/netif/bridge.go +++ b/internal/netif/bridge.go @@ -1,14 +1,17 @@ package netif import ( + "net" + "github.com/vishvananda/netlink" ) -func CreateBridge(name string, mtu int) error { +func CreateBridge(name string, mtu int, mac net.HardwareAddr) error { br := &netlink.Bridge{ LinkAttrs: netlink.LinkAttrs{ - Name: name, - MTU: mtu, + Name: name, + MTU: mtu, + HardwareAddr: mac, }, } diff --git a/internal/netif/delete.go b/internal/netif/delete.go index 9b06c55..8fc18f6 100644 --- a/internal/netif/delete.go +++ b/internal/netif/delete.go @@ -1,6 +1,8 @@ package netif import ( + "errors" + "github.com/vishvananda/netlink" ) @@ -11,3 +13,15 @@ func DeleteLink(name string) error { } return netlink.LinkDel(link) } + +func DeleteLinkIfExists(name string) error { + link, err := netlink.LinkByName(name) + if err != nil { + var notFound netlink.LinkNotFoundError + if errors.As(err, ¬Found) { + return nil + } + return err + } + return netlink.LinkDel(link) +} diff --git a/internal/netif/mac.go b/internal/netif/mac.go new file mode 100644 index 0000000..ba8300c --- /dev/null +++ b/internal/netif/mac.go @@ -0,0 +1,21 @@ +package netif + +import ( + "fmt" + "net" +) + +const ( + locallyAdministered byte = 0x02 + + RoleRouter byte = 0x02 + RoleHostGateway byte = 0x03 +) + +func HostMAC(role byte, vtep net.IP) (net.HardwareAddr, error) { + ip := vtep.To4() + if ip == nil { + return nil, fmt.Errorf("vtep %v is not an IPv4 address", vtep) + } + return net.HardwareAddr{locallyAdministered, role, ip[0], ip[1], ip[2], ip[3]}, nil +} diff --git a/internal/netif/mac_test.go b/internal/netif/mac_test.go new file mode 100644 index 0000000..5230513 --- /dev/null +++ b/internal/netif/mac_test.go @@ -0,0 +1,60 @@ +package netif + +import ( + "net" + "testing" +) + +func TestHostMAC(t *testing.T) { + cases := []struct { + role byte + vtep string + want string + }{ + {RoleHostGateway, "192.168.14.11", "02:03:c0:a8:0e:0b"}, + {RoleHostGateway, "192.168.14.12", "02:03:c0:a8:0e:0c"}, + {RoleHostGateway, "10.0.0.1", "02:03:0a:00:00:01"}, + {RoleRouter, "192.168.14.11", "02:02:c0:a8:0e:0b"}, + } + for _, c := range cases { + got, err := HostMAC(c.role, net.ParseIP(c.vtep)) + if err != nil { + t.Fatalf("rôle %#x, VTEP %s : erreur inattendue %v", c.role, c.vtep, err) + } + if got.String() != c.want { + t.Errorf("rôle %#x, VTEP %s : %s, %s attendu", c.role, c.vtep, got, c.want) + } + } +} + +func TestHostMACIsLocalUnicast(t *testing.T) { + for _, role := range []byte{RoleRouter, RoleHostGateway} { + got, err := HostMAC(role, net.ParseIP("192.168.14.11")) + if err != nil { + t.Fatal(err) + } + if got[0]&0x02 == 0 { + t.Errorf("%s : bit « administrée localement » absent", got) + } + if got[0]&0x01 != 0 { + t.Errorf("%s : MAC de groupe (multicast)", got) + } + } +} + +func TestHostMACRolesDifferOnTheSameHost(t *testing.T) { + if RoleRouter == RoleHostGateway { + t.Fatalf("rôles identiques : %#x", RoleRouter) + } + if RoleRouter != 0x02 || RoleHostGateway != 0x03 { + t.Errorf("rôles %#x / %#x, 0x02 / 0x03 attendus (valeurs publiées dans la doc)", RoleRouter, RoleHostGateway) + } +} + +func TestHostMACRejectsANonIPv4VTEP(t *testing.T) { + for _, vtep := range []net.IP{nil, net.ParseIP("fd00::1")} { + if mac, err := HostMAC(RoleHostGateway, vtep); err == nil { + t.Errorf("VTEP %v accepté : %s", vtep, mac) + } + } +} diff --git a/internal/netif/route.go b/internal/netif/route.go new file mode 100644 index 0000000..d49ec02 --- /dev/null +++ b/internal/netif/route.go @@ -0,0 +1,36 @@ +package netif + +import ( + "errors" + "net" + "syscall" + + "github.com/vishvananda/netlink" +) + +func RouteReplaceVia(table int, dst *net.IPNet, gw net.IP, iface string) error { + link, err := netlink.LinkByName(iface) + if err != nil { + return err + } + return netlink.RouteReplace(&netlink.Route{ + LinkIndex: link.Attrs().Index, + Dst: dst, + Gw: gw, + Table: table, + }) +} + +func RouteDel(table int, dst *net.IPNet) error { + return netlink.RouteDel(&netlink.Route{ + Dst: dst, + Table: table, + }) +} + +func RouteDelIfExists(table int, dst *net.IPNet) error { + if err := RouteDel(table, dst); err != nil && !errors.Is(err, syscall.ESRCH) { + return err + } + return nil +} diff --git a/internal/netif/route_linux.go b/internal/netif/route_linux.go index f68d191..fc444d1 100644 --- a/internal/netif/route_linux.go +++ b/internal/netif/route_linux.go @@ -19,3 +19,24 @@ func RouteAdd(iface string, subnet *net.IPNet) error { Scope: netlink.SCOPE_LINK, }) } + +func TableRoutesVia(table int, iface string) ([]*net.IPNet, error) { + link, err := netlink.LinkByName(iface) + if err != nil { + return nil, err + } + routes, err := netlink.RouteListFiltered(netlink.FAMILY_V4, &netlink.Route{ + Table: table, + LinkIndex: link.Attrs().Index, + }, netlink.RT_FILTER_TABLE|netlink.RT_FILTER_OIF) + if err != nil { + return nil, err + } + dsts := make([]*net.IPNet, 0, len(routes)) + for _, r := range routes { + if r.Dst != nil && r.Gw != nil { + dsts = append(dsts, r.Dst) + } + } + return dsts, nil +} diff --git a/internal/netif/route_other.go b/internal/netif/route_other.go index 685c5bf..dcfd025 100644 --- a/internal/netif/route_other.go +++ b/internal/netif/route_other.go @@ -2,8 +2,15 @@ package netif -import "net" +import ( + "errors" + "net" +) func RouteAdd(_ string, _ *net.IPNet) error { - return nil + return errors.New("not supported on this platform") +} + +func TableRoutesVia(_ int, _ string) ([]*net.IPNet, error) { + return nil, errors.New("route listing is only implemented on linux") } diff --git a/internal/netif/vrf.go b/internal/netif/vrf.go new file mode 100644 index 0000000..8d8e47e --- /dev/null +++ b/internal/netif/vrf.go @@ -0,0 +1,16 @@ +package netif + +import ( + "github.com/vishvananda/netlink" +) + +func CreateVRF(name string, table uint32) error { + vrf := &netlink.Vrf{ + LinkAttrs: netlink.LinkAttrs{Name: name}, + Table: table, + } + if err := netlink.LinkAdd(vrf); err != nil { + return err + } + return netlink.LinkSetUp(vrf) +} diff --git a/internal/netif/vxlan.go b/internal/netif/vxlan.go index 0930cb3..81ec3a2 100644 --- a/internal/netif/vxlan.go +++ b/internal/netif/vxlan.go @@ -18,11 +18,7 @@ func CreateVxlan(name string, vxlanID int, localIface string, mtu int) error { if err != nil { return err } - addrs, err := netlink.AddrList(link, syscall.AF_INET) - if err != nil { - return err - } - local, err := vtepAddress(localIface, addrs) + local, err := linkVTEPAddress(link) if err != nil { return err } @@ -40,6 +36,22 @@ func CreateVxlan(name string, vxlanID int, localIface string, mtu int) error { return netlink.LinkAdd(vxlan) } +func VTEPAddress(iface string) (net.IP, error) { + link, err := netlink.LinkByName(iface) + if err != nil { + return nil, err + } + return linkVTEPAddress(link) +} + +func linkVTEPAddress(link netlink.Link) (net.IP, error) { + addrs, err := netlink.AddrList(link, syscall.AF_INET) + if err != nil { + return nil, err + } + return vtepAddress(link.Attrs().Name, addrs) +} + func vtepAddress(iface string, addrs []netlink.Addr) (net.IP, error) { for _, a := range addrs { if a.IPNet == nil || a.IP.To4() == nil || a.Scope != scopeUniverse || a.Flags&addressSecondary != 0 { diff --git a/internal/subnet/create.go b/internal/subnet/create.go index 1164219..12d345e 100644 --- a/internal/subnet/create.go +++ b/internal/subnet/create.go @@ -2,11 +2,13 @@ package subnet import ( "fmt" + "net" configuration "git.g3e.fr/syonad/two/internal/config/agent" "git.g3e.fr/syonad/two/internal/dhcp" "git.g3e.fr/syonad/two/internal/dhcpbackend" "git.g3e.fr/syonad/two/internal/ebtables" + "git.g3e.fr/syonad/two/internal/l3vni" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" "git.g3e.fr/syonad/two/internal/state" @@ -37,6 +39,12 @@ func CreateSubnet(db *badger.DB, subnetName string, cfg *configuration.Config) e return err } + if d.mode == ModeVxlan { + if err := l3vni.ExportRoute(db, d.vpc, d.cidr); err != nil { + return err + } + } + return state.Set(db, "subnet/"+subnetName, state.Running) } @@ -66,8 +74,19 @@ func createSubnet(db *badger.DB, subnetName string, d subnetData, backend dhcpba return fmt.Errorf("unknown subnet mode %q", d.mode) } + var gatewayMAC net.HardwareAddr + if d.mode == ModeVxlan { + vtep, err := netif.VTEPAddress(d.localIface) + if err != nil { + return fmt.Errorf("vtep of %s: %w", d.localIface, err) + } + if gatewayMAC, err = netif.HostMAC(netif.RoleHostGateway, vtep); err != nil { + return err + } + } + if err := netns.Call(d.vpc, func() error { - if err := netif.CreateBridge(d.bridge, 1500); err != nil { + if err := netif.CreateBridge(d.bridge, 1500, gatewayMAC); err != nil { return fmt.Errorf("create bridge: %w", err) } return netif.BridgeSetMaster(vethI, d.bridge) @@ -122,7 +141,7 @@ func createSubnet(db *badger.DB, subnetName string, d subnetData, backend dhcpba func setupVxlanHost(d subnetData, vethE string) error { vxlanIface := fmt.Sprintf("vxlan-%d", d.vxlanID) - if err := netif.CreateBridge(d.bridge, 1500); err != nil { + if err := netif.CreateBridge(d.bridge, 1500, nil); err != nil { return fmt.Errorf("create bridge: %w", err) } if err := netif.CreateVxlan(vxlanIface, d.vxlanID, d.localIface, 1500); err != nil { diff --git a/internal/subnet/delete.go b/internal/subnet/delete.go index a8f12d0..8ee4d78 100644 --- a/internal/subnet/delete.go +++ b/internal/subnet/delete.go @@ -6,6 +6,7 @@ import ( configuration "git.g3e.fr/syonad/two/internal/config/agent" "git.g3e.fr/syonad/two/internal/dhcpbackend" "git.g3e.fr/syonad/two/internal/ebtables" + "git.g3e.fr/syonad/two/internal/l3vni" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" "git.g3e.fr/syonad/two/internal/state" @@ -33,6 +34,12 @@ func DeleteSubnet(db *badger.DB, subnetName string, cfg *configuration.Config) e return err } + if d.mode == ModeVxlan { + if err := l3vni.WithdrawRoute(db, d.vpc, d.cidr); err != nil { + return err + } + } + if err := stopDHCP(db, subnetName, d, backend); err != nil { return err } diff --git a/internal/sysctl/sysctl.go b/internal/sysctl/sysctl.go new file mode 100644 index 0000000..50f0a1a --- /dev/null +++ b/internal/sysctl/sysctl.go @@ -0,0 +1,23 @@ +package sysctl + +import ( + "fmt" + "os" + "path/filepath" + "strings" +) + +var root = "/proc/sys" + +func Set(key, value string) error { + path := filepath.Join(root, strings.ReplaceAll(key, ".", "/")) + f, err := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0) + if err != nil { + return fmt.Errorf("sysctl %s: %w", key, err) + } + if _, err := f.WriteString(value); err != nil { + f.Close() + return fmt.Errorf("sysctl %s=%s: %w", key, value, err) + } + return f.Close() +} diff --git a/internal/sysctl/sysctl_test.go b/internal/sysctl/sysctl_test.go new file mode 100644 index 0000000..e07674f --- /dev/null +++ b/internal/sysctl/sysctl_test.go @@ -0,0 +1,48 @@ +package sysctl + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +func fakeRoot(t *testing.T) string { + t.Helper() + dir := t.TempDir() + if err := os.MkdirAll(filepath.Join(dir, "net", "ipv4"), 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, "net", "ipv4", "ip_forward"), []byte("0\n"), 0o644); err != nil { + t.Fatal(err) + } + old := root + root = dir + t.Cleanup(func() { root = old }) + return dir +} + +func TestSetWritesTheValueAtTheKeyPath(t *testing.T) { + dir := fakeRoot(t) + if err := Set("net.ipv4.ip_forward", "1"); err != nil { + t.Fatal(err) + } + got, err := os.ReadFile(filepath.Join(dir, "net", "ipv4", "ip_forward")) + if err != nil { + t.Fatal(err) + } + if string(got) != "1" { + t.Errorf("contenu %q, \"1\" attendu", got) + } +} + +func TestSetRefusesAnUnknownKeyWithoutCreatingIt(t *testing.T) { + dir := fakeRoot(t) + err := Set("net.ipv4.ip_forwarding", "1") + if err == nil || !strings.Contains(err.Error(), "sysctl net.ipv4.ip_forwarding") { + t.Errorf("erreur %v", err) + } + if _, err := os.Stat(filepath.Join(dir, "net", "ipv4", "ip_forwarding")); !os.IsNotExist(err) { + t.Errorf("clé inconnue créée : %v", err) + } +} diff --git a/internal/vm/create.go b/internal/vm/create.go index 692cc25..1318750 100644 --- a/internal/vm/create.go +++ b/internal/vm/create.go @@ -10,6 +10,7 @@ import ( configuration "git.g3e.fr/syonad/two/internal/config/agent" "git.g3e.fr/syonad/two/internal/dhcpbackend" "git.g3e.fr/syonad/two/internal/iptables" + "git.g3e.fr/syonad/two/internal/l3vni" "git.g3e.fr/syonad/two/internal/metadata" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" @@ -111,6 +112,10 @@ func StartVM(db *badger.DB, name string, cfg *configuration.Config) error { return fmt.Errorf("start qemu: %w", err) } + if err := applyHostRoutes(db, d, l3vni.ExportRoute); err != nil { + return err + } + return state.Set(db, "vm/"+name, state.Running) } diff --git a/internal/vm/delete.go b/internal/vm/delete.go index 9b2a50c..304a75d 100644 --- a/internal/vm/delete.go +++ b/internal/vm/delete.go @@ -9,6 +9,7 @@ import ( configuration "git.g3e.fr/syonad/two/internal/config/agent" "git.g3e.fr/syonad/two/internal/dhcpbackend" "git.g3e.fr/syonad/two/internal/iptables" + "git.g3e.fr/syonad/two/internal/l3vni" "git.g3e.fr/syonad/two/internal/metadata" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" @@ -38,6 +39,10 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { return err } + if err := applyHostRoutes(db, d, l3vni.WithdrawRoute); err != nil { + return err + } + socketPath := filepath.Join(cfg.QEMU.QMPDir, name+".sock") if _, err := os.Stat(socketPath); err == nil { diff --git a/internal/vm/routes.go b/internal/vm/routes.go new file mode 100644 index 0000000..09090f7 --- /dev/null +++ b/internal/vm/routes.go @@ -0,0 +1,43 @@ +package vm + +import ( + "fmt" + "net" + + "github.com/dgraph-io/badger/v4" +) + +type hostRoute struct { + vpc string + dst *net.IPNet +} + +type routeFunc func(db *badger.DB, vpcName string, dst *net.IPNet) error + +func hostRoutes(d vmData) ([]hostRoute, error) { + var routes []hostRoute + for _, n := range d.nics { + if n.mode != "vxlan" { + continue + } + ip := net.ParseIP(n.ip).To4() + if ip == nil { + return nil, fmt.Errorf("interface %d: %q is not an IPv4 address", n.index, n.ip) + } + routes = append(routes, hostRoute{vpc: n.vpcName, dst: &net.IPNet{IP: ip, Mask: net.CIDRMask(32, 32)}}) + } + return routes, nil +} + +func applyHostRoutes(db *badger.DB, d vmData, apply routeFunc) error { + routes, err := hostRoutes(d) + if err != nil { + return err + } + for _, r := range routes { + if err := apply(db, r.vpc, r.dst); err != nil { + return err + } + } + return nil +} diff --git a/internal/vm/routes_test.go b/internal/vm/routes_test.go new file mode 100644 index 0000000..592b44d --- /dev/null +++ b/internal/vm/routes_test.go @@ -0,0 +1,66 @@ +package vm + +import ( + "errors" + "net" + "reflect" + "strings" + "testing" + + "github.com/dgraph-io/badger/v4" +) + +func routedVM() vmData { + return vmData{nics: []nicData{ + {index: 0, vpcName: "vp-s7", mode: "vxlan", ip: "10.241.1.10"}, + {index: 1, vpcName: "vp-s7", mode: "bridge", ip: "192.168.50.10"}, + {index: 2, vpcName: "vp-s7", mode: "vxlan", ip: "10.241.2.10"}, + }} +} + +type recorder struct { + calls []string + fail string +} + +func (r *recorder) apply(_ *badger.DB, vpcName string, dst *net.IPNet) error { + r.calls = append(r.calls, vpcName+" "+dst.String()) + if dst.String() == r.fail { + return errors.New("refused") + } + return nil +} + +func TestApplyHostRoutesCoversEveryVxlanInterfaceAsA32(t *testing.T) { + r := &recorder{} + if err := applyHostRoutes(nil, routedVM(), r.apply); err != nil { + t.Fatal(err) + } + want := []string{"vp-s7 10.241.1.10/32", "vp-s7 10.241.2.10/32"} + if !reflect.DeepEqual(r.calls, want) { + t.Errorf("appels %q, attendu %q", r.calls, want) + } +} + +func TestApplyHostRoutesStopsAtTheFirstError(t *testing.T) { + r := &recorder{fail: "10.241.1.10/32"} + if err := applyHostRoutes(nil, routedVM(), r.apply); err == nil || err.Error() != "refused" { + t.Errorf("erreur %v", err) + } + if len(r.calls) != 1 { + t.Errorf("appels après l'échec : %q", r.calls) + } +} + +func TestApplyHostRoutesRefusesANonIPv4AddressBeforeAnyCall(t *testing.T) { + d := routedVM() + d.nics[2].ip = "fd00::10" + r := &recorder{} + err := applyHostRoutes(nil, d, r.apply) + if err == nil || !strings.Contains(err.Error(), `interface 2: "fd00::10" is not an IPv4 address`) { + t.Errorf("erreur %v", err) + } + if len(r.calls) != 0 { + t.Errorf("appels : %q", r.calls) + } +} diff --git a/internal/vpc/create.go b/internal/vpc/create.go index 52e2567..c0377bf 100644 --- a/internal/vpc/create.go +++ b/internal/vpc/create.go @@ -3,6 +3,8 @@ package vpc import ( "strings" + configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/l3vni" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" "git.g3e.fr/syonad/two/internal/state" @@ -10,7 +12,7 @@ import ( "github.com/dgraph-io/badger/v4" ) -func CreateVPC(db *badger.DB, name string) error { +func CreateVPC(db *badger.DB, name string, cfg *configuration.Config) error { if current, err := state.Get(db, "vpc/"+name); err != nil { return err } else if current == state.Creating { @@ -25,7 +27,7 @@ func CreateVPC(db *badger.DB, name string) error { } if err := netns.Call(name, func() error { - return netif.CreateBridge("br-public", 1500) + return netif.CreateBridge("br-public", 1500, nil) }); err != nil { return err } @@ -48,6 +50,9 @@ func CreateVPC(db *badger.DB, name string) error { }); err != nil { return err } + if err := l3vni.Create(db, name, cfg); err != nil { + return err + } return state.Set(db, "vpc/"+name, state.Running) } return nil diff --git a/internal/vpc/delete.go b/internal/vpc/delete.go index ff4d83f..d26a052 100644 --- a/internal/vpc/delete.go +++ b/internal/vpc/delete.go @@ -3,6 +3,7 @@ package vpc import ( "strings" + "git.g3e.fr/syonad/two/internal/l3vni" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" "git.g3e.fr/syonad/two/internal/state" @@ -16,6 +17,10 @@ func DeleteVPC(db *badger.DB, name string) error { } else if current == state.Deleting { vpcID := strings.SplitN(name, "-", 2)[1] + if err := l3vni.Delete(db, name); err != nil { + return err + } + if err := netif.DeleteLink("vp-" + vpcID + "-e"); err != nil { return err } diff --git a/internal/watchdog/check_l3.go b/internal/watchdog/check_l3.go new file mode 100644 index 0000000..0fee453 --- /dev/null +++ b/internal/watchdog/check_l3.go @@ -0,0 +1,232 @@ +package watchdog + +import ( + "fmt" + "net" + "sort" + "strings" + + configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/frr" + "git.g3e.fr/syonad/two/internal/l3vni" + "git.g3e.fr/syonad/two/internal/netif" + "git.g3e.fr/syonad/two/internal/netns" + "git.g3e.fr/syonad/two/internal/state" + "git.g3e.fr/syonad/two/internal/watchdog/notify" + "git.g3e.fr/syonad/two/pkg/db/kv" + + "github.com/dgraph-io/badger/v4" +) + +const kindBGP = "bgp" + +type l3Probe interface { + VTEPAddress(iface string) (net.IP, error) + NeighborEstablished(peer net.IP) (bool, error) + VNI(vni uint32) (frr.VNIState, error) + ExportedRoutes(table uint32, iface string) ([]*net.IPNet, error) + LinkProblem(ns, iface string) string +} + +type systemProbe struct { + frr *frr.Client +} + +func (systemProbe) VTEPAddress(iface string) (net.IP, error) { return netif.VTEPAddress(iface) } + +func (p systemProbe) NeighborEstablished(peer net.IP) (bool, error) { + return p.frr.NeighborEstablished(peer) +} + +func (p systemProbe) VNI(vni uint32) (frr.VNIState, error) { return p.frr.VNI(vni) } + +func (systemProbe) ExportedRoutes(table uint32, iface string) ([]*net.IPNet, error) { + return netif.TableRoutesVia(int(table), iface) +} + +func (systemProbe) LinkProblem(ns, iface string) string { + if ns == "" { + return linkProblem(iface) + } + var p string + if err := netns.Call(ns, func() error { + p = linkProblem(iface) + return nil + }); err != nil { + return fmt.Sprintf("cannot enter netns %s: %v", ns, err) + } + if p != "" { + return p + " (in netns)" + } + return "" +} + +func CheckBGP(cfg *configuration.Config, p l3Probe, n notify.Notifier) { + if !cfg.BGP.Enabled() { + return + } + reflectors, err := cfg.BGP.Reflectors() + if err != nil { + n.Notify(kindBGP, "config", err.Error()) + return + } + for _, rr := range reflectors { + up, err := p.NeighborEstablished(rr) + switch { + case err != nil: + n.Notify(kindBGP, rr.String(), fmt.Sprintf("session unreadable: %v", err)) + case !up: + n.Notify(kindBGP, rr.String(), "session to the route reflector is not established") + } + } +} + +func CheckL3VPCs(db *badger.DB, cfg *configuration.Config, p l3Probe, n notify.Notifier) error { + pairs, err := kv.ListByPrefix(db, prefixVPC) + if err != nil { + return fmt.Errorf("watchdog: listing vpcs: %w", err) + } + var rmac string + for _, name := range resourceNames(pairs, prefixVPC) { + if st, err := state.Get(db, prefixVPC+name); err != nil || st != state.Running { + continue + } + r, ok, err := l3vni.LoadRouting(db, name) + if err != nil { + n.Notify(kindVPC, name, err.Error()) + continue + } + if !ok { + continue + } + if !cfg.BGP.Enabled() { + n.Notify(kindVPC, name, "vpc has an l3vni but the agent configuration has no bgp section") + continue + } + if rmac == "" { + rmac = expectedRouterMAC(cfg, p, n) + } + checkL3VPC(db, name, r, rmac, p, n) + } + return nil +} + +func expectedRouterMAC(cfg *configuration.Config, p l3Probe, n notify.Notifier) string { + vtep, err := p.VTEPAddress(cfg.DefaultInterface) + if err != nil { + n.Notify(kindBGP, "vtep", fmt.Sprintf("vtep address unreadable on %s: %v", cfg.DefaultInterface, err)) + return "unknown" + } + mac, err := l3vni.RouterMAC(vtep) + if err != nil { + n.Notify(kindBGP, "vtep", err.Error()) + return "unknown" + } + return mac.String() +} + +func checkL3VPC(db *badger.DB, name string, r l3vni.Routing, rmac string, p l3Probe, n notify.Notifier) { + for _, iface := range []string{r.VRF, r.Bridge, r.Vxlan, r.VethHost} { + if problem := p.LinkProblem("", iface); problem != "" { + n.Notify(kindVPC, name, problem) + } + } + if problem := p.LinkProblem(name, r.VethNetns); problem != "" { + n.Notify(kindVPC, name, problem) + } + + s, err := p.VNI(r.VNI) + switch { + case err != nil: + n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d unreadable in frr: %v", r.VNI, err)) + case s.Type != "L3" || s.State != "Up": + n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d is type %q state %q in frr, expected L3 Up", r.VNI, s.Type, s.State)) + case rmac != "unknown" && s.RouterMAC != rmac: + n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d has router mac %q in frr, expected %s", r.VNI, s.RouterMAC, rmac)) + } + + actual, err := p.ExportedRoutes(r.VNI, r.VethHost) + if err != nil { + n.Notify(kindVPC, name, fmt.Sprintf("routes of %s unreadable: %v", r.VRF, err)) + return + } + expected, tolerated, err := expectedExports(db, name) + if err != nil { + n.Notify(kindVPC, name, err.Error()) + return + } + exported := make(map[string]bool, len(actual)) + for _, dst := range actual { + exported[dst.String()] = true + } + for _, dst := range sortedKeys(exported) { + if !expected[dst] && !tolerated[dst] { + n.Notify(kindVPC, name, fmt.Sprintf("route %s exported in %s without a running owner: its traffic is black-holed", dst, r.VRF)) + } + } + for _, dst := range sortedKeys(expected) { + if !exported[dst] { + n.Notify(kindVPC, name, fmt.Sprintf("route %s not exported in %s", dst, r.VRF)) + } + } +} + +func expectedExports(db *badger.DB, vpcName string) (expected, tolerated map[string]bool, err error) { + expected, tolerated = map[string]bool{}, map[string]bool{} + classify := func(st state.State, dst string) { + switch st { + case state.Running: + expected[dst] = true + case state.Creating, state.Deleting, state.Error: + tolerated[dst] = true + } + } + + subnets, err := kv.ListByPrefix(db, prefixSubnet) + if err != nil { + return nil, nil, fmt.Errorf("watchdog: listing subnets: %w", err) + } + routed := map[string]bool{} + for key, value := range subnets { + subnet, ok := strings.CutSuffix(strings.TrimPrefix(key, prefixSubnet), "/vpc") + if !ok || strings.Contains(subnet, "/") || value != vpcName || subnets[prefixSubnet+subnet+"/mode"] != "vxlan" { + continue + } + routed[subnet] = true + _, cidr, err := net.ParseCIDR(subnets[prefixSubnet+subnet+"/cidr"]) + if err != nil { + continue + } + if st, err := state.Get(db, prefixSubnet+subnet); err == nil { + classify(st, cidr.String()) + } + } + + vms, err := kv.ListByPrefix(db, prefixVM) + if err != nil { + return nil, nil, fmt.Errorf("watchdog: listing vms: %w", err) + } + for key, value := range vms { + parts := strings.Split(key, "/") + if len(parts) != 5 || parts[2] != "nic" || parts[4] != "subnet" || !routed[value] { + continue + } + ip := net.ParseIP(vms[strings.TrimSuffix(key, "subnet")+"ip"]).To4() + if ip == nil { + continue + } + if st, err := state.Get(db, prefixVM+parts[1]); err == nil { + classify(st, ip.String()+"/32") + } + } + return expected, tolerated, nil +} + +func sortedKeys(m map[string]bool) []string { + keys := make([]string, 0, len(m)) + for k := range m { + keys = append(keys, k) + } + sort.Strings(keys) + return keys +} diff --git a/internal/watchdog/check_l3_test.go b/internal/watchdog/check_l3_test.go new file mode 100644 index 0000000..c307b30 --- /dev/null +++ b/internal/watchdog/check_l3_test.go @@ -0,0 +1,242 @@ +package watchdog + +import ( + "errors" + "net" + "reflect" + "testing" + + configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/frr" + "git.g3e.fr/syonad/two/internal/state" +) + +type fakeProbe struct { + established map[string]bool + neighborErr error + vni map[uint32]frr.VNIState + routes map[uint32][]string + routesErr error + links map[string]string + vtepErr error +} + +func (f *fakeProbe) VTEPAddress(string) (net.IP, error) { + if f.vtepErr != nil { + return nil, f.vtepErr + } + return net.ParseIP("192.168.14.11"), nil +} + +func (f *fakeProbe) NeighborEstablished(peer net.IP) (bool, error) { + return f.established[peer.String()], f.neighborErr +} + +func (f *fakeProbe) VNI(vni uint32) (frr.VNIState, error) { + s, ok := f.vni[vni] + if !ok { + return s, errors.New("% VNI does not exist") + } + return s, nil +} + +func (f *fakeProbe) ExportedRoutes(table uint32, _ string) ([]*net.IPNet, error) { + var out []*net.IPNet + for _, r := range f.routes[table] { + _, n, _ := net.ParseCIDR(r) + out = append(out, n) + } + return out, f.routesErr +} + +func (f *fakeProbe) LinkProblem(ns, iface string) string { + return f.links[ns+"/"+iface] +} + +func bgpCfg() *configuration.Config { + cfg := &configuration.Config{DefaultInterface: "br-000000"} + cfg.BGP.ASN = 64600 + cfg.BGP.RouteReflectors = []string{"10.255.255.1", "10.255.255.2"} + return cfg +} + +func notified(r *recorder) []string { + var out []string + for _, c := range r.calls { + out = append(out, c.kind+" "+c.name+": "+c.problem) + } + return out +} + +func TestCheckBGPReportsEachReflectorWithoutSession(t *testing.T) { + r := &recorder{} + CheckBGP(bgpCfg(), &fakeProbe{established: map[string]bool{"10.255.255.1": true}}, r) + want := []string{"bgp 10.255.255.2: session to the route reflector is not established"} + if got := notified(r); !reflect.DeepEqual(got, want) { + t.Errorf("notifications %q, attendu %q", got, want) + } +} + +func TestCheckBGPReportsAnUnreadableSession(t *testing.T) { + r := &recorder{} + CheckBGP(bgpCfg(), &fakeProbe{neighborErr: errors.New("vtysh absent")}, r) + if len(r.calls) != 2 || !r.hasProblemContaining("session unreadable: vtysh absent") { + t.Errorf("notifications %q", notified(r)) + } +} + +func TestCheckBGPIsSilentWithoutBGPSection(t *testing.T) { + r := &recorder{} + CheckBGP(&configuration.Config{}, &fakeProbe{}, r) + if len(r.calls) != 0 { + t.Errorf("notifications %q", notified(r)) + } +} + +func seedRoutedVPC(t *testing.T) *fakeProbe { + return &fakeProbe{ + vni: map[uint32]frr.VNIState{2700: {Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:0b"}}, + } +} + +func TestCheckL3VPCsReconcilesExportedRoutesWithTheirOwners(t *testing.T) { + db := newTestDB(t) + seedResource(t, db, prefixVPC, "vp-s7", state.Running) + seedKV(t, db, "vpc/vp-s7/cidr", "10.241.0.0/16") + seedKV(t, db, "vpc/vp-s7/l3vni", "2700") + seedResource(t, db, prefixVPC, "vp-flat", state.Running) + seedKV(t, db, "vpc/vp-flat/cidr", "10.242.0.0/16") + + seedResource(t, db, prefixSubnet, "sn-a", state.Running) + seedKV(t, db, "subnet/sn-a/vpc", "vp-s7") + seedKV(t, db, "subnet/sn-a/mode", "vxlan") + seedKV(t, db, "subnet/sn-a/cidr", "10.241.1.0/24") + seedResource(t, db, prefixSubnet, "sn-b", state.Creating) + seedKV(t, db, "subnet/sn-b/vpc", "vp-s7") + seedKV(t, db, "subnet/sn-b/mode", "vxlan") + seedKV(t, db, "subnet/sn-b/cidr", "10.241.2.0/24") + seedResource(t, db, prefixSubnet, "sn-br", state.Running) + seedKV(t, db, "subnet/sn-br/vpc", "vp-s7") + seedKV(t, db, "subnet/sn-br/mode", "bridge") + seedKV(t, db, "subnet/sn-br/cidr", "192.168.50.0/24") + + vm := func(name string, st state.State, subnet, ip string) { + seedResource(t, db, prefixVM, name, st) + seedKV(t, db, "vm/"+name+"/nic/0/subnet", subnet) + seedKV(t, db, "vm/"+name+"/nic/0/ip", ip) + } + vm("i-run", state.Running, "sn-a", "10.241.1.10") + vm("i-missing", state.Running, "sn-a", "10.241.1.11") + vm("i-starting", state.Creating, "sn-a", "10.241.1.12") + vm("i-gone", state.Deleted, "sn-a", "10.241.1.13") + vm("i-bridge", state.Running, "sn-br", "192.168.50.10") + seedResource(t, db, prefixSubnet, "sn-flat", state.Running) + seedKV(t, db, "subnet/sn-flat/vpc", "vp-flat") + seedKV(t, db, "subnet/sn-flat/mode", "vxlan") + seedKV(t, db, "subnet/sn-flat/cidr", "10.242.1.0/24") + vm("i-flat", state.Running, "sn-flat", "10.242.1.10") + + p := seedRoutedVPC(t) + p.routes = map[uint32][]string{2700: { + "10.241.1.0/24", "10.241.2.0/24", + "10.241.1.10/32", "10.241.1.12/32", "10.241.1.13/32", "10.241.1.50/32", + }} + r := &recorder{} + if err := CheckL3VPCs(db, bgpCfg(), p, r); err != nil { + t.Fatal(err) + } + want := []string{ + "vpc vp-s7: route 10.241.1.13/32 exported in vrf-s7 without a running owner: its traffic is black-holed", + "vpc vp-s7: route 10.241.1.50/32 exported in vrf-s7 without a running owner: its traffic is black-holed", + "vpc vp-s7: route 10.241.1.11/32 not exported in vrf-s7", + } + if got := notified(r); !reflect.DeepEqual(got, want) { + t.Errorf("notifications :\n%q\nattendu :\n%q", got, want) + } +} + +func TestCheckL3VPCsChecksInterfacesAndTheL3VNI(t *testing.T) { + db := newTestDB(t) + seedResource(t, db, prefixVPC, "vp-s7", state.Running) + seedKV(t, db, "vpc/vp-s7/cidr", "10.241.0.0/16") + seedKV(t, db, "vpc/vp-s7/l3vni", "2700") + seedResource(t, db, prefixVPC, "vp-down", state.Error) + seedKV(t, db, "vpc/vp-down/cidr", "10.243.0.0/16") + seedKV(t, db, "vpc/vp-down/l3vni", "2800") + + p := &fakeProbe{ + vni: map[uint32]frr.VNIState{2700: {Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:99"}}, + links: map[string]string{"/vxl3-s7": "interface vxl3-s7 down", "vp-s7/l3-s7-i": "interface l3-s7-i not found (in netns)"}, + } + r := &recorder{} + if err := CheckL3VPCs(db, bgpCfg(), p, r); err != nil { + t.Fatal(err) + } + want := []string{ + "vpc vp-s7: interface vxl3-s7 down", + "vpc vp-s7: interface l3-s7-i not found (in netns)", + `vpc vp-s7: l3vni 2700 has router mac "02:02:c0:a8:0e:99" in frr, expected 02:02:c0:a8:0e:0b`, + } + if got := notified(r); !reflect.DeepEqual(got, want) { + t.Errorf("notifications :\n%q\nattendu :\n%q", got, want) + } + + p.vni[2700] = frr.VNIState{Type: "L2", State: "Up"} + p.links = nil + r = &recorder{} + CheckL3VPCs(db, bgpCfg(), p, r) + if !r.hasProblemContaining(`l3vni 2700 is type "L2" state "Up" in frr, expected L3 Up`) { + t.Errorf("notifications %q", notified(r)) + } + + p.vni[2700] = frr.VNIState{Type: "L3", State: "Down", RouterMAC: "02:02:c0:a8:0e:0b"} + r = &recorder{} + CheckL3VPCs(db, bgpCfg(), p, r) + if !r.hasProblemContaining(`l3vni 2700 is type "L3" state "Down" in frr, expected L3 Up`) { + t.Errorf("notifications %q", notified(r)) + } + + delete(p.vni, 2700) + r = &recorder{} + CheckL3VPCs(db, bgpCfg(), p, r) + if !r.hasProblemContaining("l3vni 2700 unreadable in frr") { + t.Errorf("notifications %q", notified(r)) + } +} + +func TestCheckL3VPCsReportsAnL3VNIWithoutBGP(t *testing.T) { + db := newTestDB(t) + seedResource(t, db, prefixVPC, "vp-s7", state.Running) + seedKV(t, db, "vpc/vp-s7/cidr", "10.241.0.0/16") + seedKV(t, db, "vpc/vp-s7/l3vni", "2700") + r := &recorder{} + CheckL3VPCs(db, &configuration.Config{}, &fakeProbe{}, r) + want := []string{"vpc vp-s7: vpc has an l3vni but the agent configuration has no bgp section"} + if got := notified(r); !reflect.DeepEqual(got, want) { + t.Errorf("notifications %q, attendu %q", got, want) + } +} + +func TestCheckL3VPCsReportsUnreadableRoutesAndVTEP(t *testing.T) { + db := newTestDB(t) + seedResource(t, db, prefixVPC, "vp-s7", state.Running) + seedKV(t, db, "vpc/vp-s7/cidr", "10.241.0.0/16") + seedKV(t, db, "vpc/vp-s7/l3vni", "2700") + seedResource(t, db, prefixVPC, "vp-s8", state.Running) + seedKV(t, db, "vpc/vp-s8/cidr", "10.242.0.0/16") + seedKV(t, db, "vpc/vp-s8/l3vni", "2800") + p := seedRoutedVPC(t) + p.routesErr = errors.New("netlink refused") + p.vtepErr = errors.New("no address") + r := &recorder{} + CheckL3VPCs(db, bgpCfg(), p, r) + if n := len(r.forName("vtep")); n != 1 { + t.Errorf("VTEP illisible signalé %d fois, attendu une fois par passage : %q", n, notified(r)) + } + if !r.hasProblemContaining("routes of vrf-s7 unreadable: netlink refused") || !r.hasProblemContaining("vtep address unreadable on br-000000") { + t.Errorf("notifications %q", notified(r)) + } + if r.hasProblemContaining("router mac") { + t.Errorf("RMAC comparée sans VTEP : %q", notified(r)) + } +} diff --git a/internal/watchdog/watchdog.go b/internal/watchdog/watchdog.go index 6da33b8..7a0101f 100644 --- a/internal/watchdog/watchdog.go +++ b/internal/watchdog/watchdog.go @@ -6,6 +6,7 @@ import ( "time" configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/frr" "git.g3e.fr/syonad/two/internal/watchdog/notify" "git.g3e.fr/syonad/two/pkg/systemd" @@ -21,6 +22,7 @@ type Watchdog struct { logger *slog.Logger interval time.Duration dbusDown bool + l3 l3Probe } func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *slog.Logger, interval time.Duration) *Watchdog { @@ -38,6 +40,7 @@ func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *sl notifier: n, logger: logger, interval: interval, + l3: systemProbe{frr: frr.NewClient()}, } } @@ -71,6 +74,10 @@ func (w *Watchdog) tick() { if err := CheckVMs(w.db, w.cfg, u, w.notifier); err != nil { w.logger.Error("watchdog: vm check failed", "err", err) } + CheckBGP(w.cfg, w.l3, w.notifier) + if err := CheckL3VPCs(w.db, w.cfg, w.l3, w.notifier); err != nil { + w.logger.Error("watchdog: l3 vpc check failed", "err", err) + } } func (w *Watchdog) units() (unitChecker, func()) { diff --git a/release_notes/0.2.0.md b/release_notes/0.2.0.md index 5f42489..950937e 100644 --- a/release_notes/0.2.0.md +++ b/release_notes/0.2.0.md @@ -1,6 +1,7 @@ # Bael -Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet. +Serveur DHCP intégré, en coexistence avec dnsmasq ; routage inter-subnet entre hyperviseurs par +L3VNI, avec une configuration BGP pilotée par l'agent ; documentation du projet. ## Fonctionnalités @@ -31,8 +32,45 @@ Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet. subnet déjà créé reste servi par le serveur qui l'a été. La procédure est documentée - Toute valeur autre que `dnsmasq` ou `two` fait échouer le démarrage de l'agent +**Routage inter-subnet entre hyperviseurs : L3VNI (#41)** + +- Nouveau champ facultatif `l3vni` sur `POST /vpcs` (1 à 65535, sauf 253-255 : c'est aussi + l'identifiant de la table de routage, et le numéro du RD `:`, sur 16 bits). + Absent, le VPC se comporte comme avant. Une L3VNI déjà portée par un VPC de l'agent est refusée + (409), comme un `l3vni` demandé sans section `bgp` +- Pour un VPC routé, l'agent pose sur l'hyperviseur une VRF (table = L3VNI), un bridge à la MAC de + routeur `02:02:`, le VXLAN de la L3VNI, un lien de transit `169.254.0.1/30` ↔ + `169.254.0.2/30` vers le netns et la route du `cidr` du VPC dans le netns ; FRR reçoit la VRF, + sa `vni`, une instance `router bgp … vrf` (RD `:`, RT `:`) et l'export + des routes du `cidr`. Un hyperviseur n'a plus besoin de porter un subnet pour joindre ses VM +- Routes annoncées : le `/24` de chaque subnet `vxlan` à sa création, le `/32` de chaque interface + de VM juste avant son passage en `running` ; retirés en premier à la suppression +- La suppression d'un VPC routé retire la configuration de routage de FRR, puis les interfaces, + puis la VRF de FRR — dans cet ordre, faute de quoi `bgpd` plante (FRR 10.7.1) + +**Configuration BGP pilotée par l'agent** + +- Nouvelle section facultative `bgp` (`asn`, `route_reflectors`). Présente, l'agent applique à + chaque démarrage, par `vtysh`, la base BGP de l'hyperviseur (router-id = VTEP, peer-group + `fabric` vers les route reflectors, EVPN, `advertise-all-vni`) et l'enregistre : + `/etc/frr/frr.conf` devient un fichier généré. Un route reflector retiré de la liste est retiré + de FRR. Absente, l'agent ne touche pas à FRR +- Le démarrage échoue si la section est incomplète, si FRR tourne déjà sous un autre AS ou si + `vtysh` ne répond pas + +**Gateway des subnets `vxlan`** + +- Le bridge du subnet porte une **MAC propre à l'hôte**, `02:03:`, posée à la + création du subnet. Une MAC identique sur tous les hôtes (anycast) a été essayée puis retirée : + annoncée en double en EVPN, elle empêchait aussi une gateway de joindre en L2 une VM d'un autre + hôte (#57) + **Exploitation** +- Le watchdog contrôle aussi, avec une section `bgp` : les sessions vers les route reflectors ; + pour chaque VPC routé, les interfaces de la VRF et l'état de la L3VNI dans FRR (type, état, MAC + de routeur) ; la cohérence entre routes exportées et ressources `running` — une route exportée + sans propriétaire est signalée comme **trou noir**, une route attendue absente comme manquante - Le watchdog interroge le serveur DHCP intégré et compare les réservations servies à celles que la base implique. Il nomme ce qui diverge — ordre perdu à la création, ordre perdu à la suppression, adresse ou route par défaut divergente — et reste en lecture seule @@ -42,6 +80,9 @@ Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet. ## Correctifs +- **Suppression d'un subnet refusée tant qu'une VM non supprimée l'utilise** (409, avec la liste + des VM), pour tous les subnets : garantit qu'une route `/32` est retirée avant le `/24` de son + subnet, ce qui évite un trou noir partiel mesuré en lab - **Un fichier de configuration présent mais invalide fait désormais échouer le démarrage.** Jusqu'en 0.1.0 l'erreur de lecture était ignorée : l'agent tournait alors entièrement sur ses valeurs par défaut sans le dire, ce qui rendait indétectable une simple tabulation d'indentation @@ -50,6 +91,11 @@ Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet. ## Changements internes +- Nouveaux paquets `internal/frr` (seul point d'appel à `vtysh` : génération des commandes, + démontage ordonné, relecture de la configuration après démontage) et `internal/sysctl` ; une + remarque de `vtysh` (« Configuration applied with notes ») n'est pas une erreur, et la + suppression d'une instance BGP de VRF est réessayée tant que `bgpd` n'a pas libéré la L3VNI +- Les tests du dispatcher arrêtent les workers avant de fermer la base (#47) - Le module passe à **Go 1.25**, exigé par la bibliothèque DHCP retenue. La version de Go du workflow de build, restée à 1.21 alors que le module en demandait davantage, est alignée - Nouveau paquet `pkg/db/statefile` : persistance générique d'un état de composant dans un @@ -63,6 +109,14 @@ Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet. Celles de la 0.1.0 restent valables, sauf mention contraire ci-dessus. S'y ajoutent : +- **L3VNI** : pas de migration à chaud ; le cache ARP d'une VM qui changerait d'hôte reste à + traiter (#57). MTU 1500 de bout en bout (#56). Un seul route reflector qualifié (#54). Le + transit `169.254.0.0/30` étant identique sur tous les hôtes, les ICMP des sauts distants sont + rejetés comme « martiens » (traceroute partiel) +- Avec une section `bgp`, l'agent ne démarre pas sans FRR et `agent.service` ne le relance pas : + au démarrage, l'ordre est migration réseau, puis FRR, puis l'agent (#52) +- `bootstrap_kvm.sh` active `net.ipv4.ip_forward` en global ; le forwarding que l'agent active + sur les seules interfaces de la VRF n'en restreint donc pas la portée - **dnsmasq n'est pas retiré** et reste un paquet requis : le backend intégré ne sert que les subnets créés après la bascule, et le retour arrière suppose dnsmasq installé - Pas de DNS, pas de pool dynamique, pas de PXE, pas de DHCPv6 dans le serveur intégré @@ -82,6 +136,11 @@ curl -O https://git.g3e.fr/syonad/two/raw/branch/main/scripts/deploy.sh bash ./deploy.sh -t 0.2.0 ``` -Aucune action n'est requise : sans `dhcp.backend` dans `/etc/two/agent.yml`, le comportement est -celui de la 0.1.0. Pour passer au serveur intégré, suivre la procédure de bascule dans la +Aucune action n'est requise : sans `dhcp.backend` ni `bgp` dans `/etc/two/agent.yml`, le +comportement est celui de la 0.1.0, à une exception près — **un subnet encore utilisé par une VM +ne se supprime plus** : supprimer les VM d'abord. Les subnets `vxlan` existants gardent leur MAC +de gateway jusqu'à leur recréation. + +Pour router entre hyperviseurs : ajouter la section `bgp`, réduire `frr.conf` à `hostname` et +`log` (l'agent pose le reste), puis créer les VPC avec `l3vni`. Pour passer au serveur intégré, suivre la procédure de bascule dans la documentation d'exploitation — elle suppose un hyperviseur vidé. diff --git a/scripts/lab-host.sh b/scripts/lab-host.sh index d06c1d7..5072f5f 100755 --- a/scripts/lab-host.sh +++ b/scripts/lab-host.sh @@ -2,7 +2,8 @@ API_URL="${SCW_API_URL:-https://api.scaleway.com}" CREDENTIALS_FILE="${LAB_CREDENTIALS_FILE:-${HOME}/.config/two-lab/scaleway.env}" -OFFER_NAME="${LAB_OFFER:-EM-B212X-SSD}" +OFFER_NAME="${LAB_OFFER:-EM-B420E-NVME}" +ALL_ZONES="fr-par-1 fr-par-2 nl-ams-1 nl-ams-2 pl-waw-2 pl-waw-3" OS_NAME="${LAB_OS_NAME:-Debian}" OS_VERSION="${LAB_OS_VERSION:-12}" LAB_NAME="${LAB_NAME:-two-lab}" @@ -30,20 +31,21 @@ usage: ${0##*/} [arguments] et le prix ; ne crée rien up crée le serveur de lab, attend la fin de son installation et son SSH, puis le prépare (voir prepare) - status liste les serveurs de lab du projet + status liste les serveurs de lab du projet, dans toutes les zones candidates ssh [commande] se connecte au serveur de lab ; avec une commande, un terminal n'est demandé que si l'entrée standard en est un prepare installe sur le serveur ce dont lab a besoin (qemu, genisoimage), vérifie - /dev/kvm et la virtualisation imbriquée ; lancé aussi par up + /dev/kvm, la virtualisation imbriquée et un CPU x86-64-v3 ; lancé aussi par up push compile cmd/lab pour linux/amd64 et dépose sur le serveur ~/lab et le répertoire de la topologie dans ~/topology/ (avec les fichiers qu'elle référence) ; ensuite : ssh './lab up topology/' - down supprime tous les serveurs de lab du projet et attend leur disparition + down supprime tous les serveurs de lab du projet, dans toutes les zones candidates, + et attend leur disparition session [cmd] up, puis la commande distante (ou un shell), puis down quoi qu'il arrive environnement : SCW_SECRET_KEY et SCW_DEFAULT_PROJECT_ID (requis, à défaut lus dans ${CREDENTIALS_FILE}, - fichier en 0600, lignes CLÉ=valeur), SCW_DEFAULT_ZONE (${ZONE}), - LAB_OFFER (${OFFER_NAME}), LAB_OS_NAME (${OS_NAME}), LAB_OS_VERSION (${OS_VERSION}), + fichier en 0600, lignes CLÉ=valeur), LAB_ZONES (zones candidates, dans l'ordre : + ${ZONES} ; SCW_DEFAULT_ZONE passe en tête), LAB_OFFER (${OFFER_NAME}), LAB_OS_NAME (${OS_NAME}), LAB_OS_VERSION (${OS_VERSION}), LAB_SSH_KEY (${SSH_KEY} ; à défaut, l'agent SSH) ne jamais lancer sous 'bash -x' : la trace afficherait SCW_SECRET_KEY. @@ -64,10 +66,19 @@ load_credentials () { esac done < "${CREDENTIALS_FILE}" fi - ZONE="${SCW_DEFAULT_ZONE:-fr-par-1}" + ZONES=$(candidate_zones "${SCW_DEFAULT_ZONE:-}" "${LAB_ZONES:-${ALL_ZONES}}") + ZONE="${ZONES%% *}" PROJECT_ID="${SCW_DEFAULT_PROJECT_ID:-}" } +candidate_zones () { + local PREFERRED="${1}" LIST="${2}" Z OUT="${1}" + for Z in ${LIST}; do + [[ " ${OUT} " == *" ${Z} "* ]] || OUT="${OUT:+${OUT} }${Z}" + done + printf '%s\n' "${OUT}" +} + require_env () { [[ -n "${SCW_SECRET_KEY:-}" ]] || die "SCW_SECRET_KEY absent de l'environnement" [[ -n "${PROJECT_ID}" ]] || die "SCW_DEFAULT_PROJECT_ID absent de l'environnement" @@ -124,7 +135,7 @@ resolve_offer () { [[ $(jq -r '.stock' <<< "${OFFER}") != "empty" ]] || die "offre ${OFFER_NAME} en rupture de stock en ${ZONE}" [[ $(jq -r '((.fee.units // 0) == 0) and ((.fee.nanos // 0) == 0)' <<< "${OFFER}") == "true" ]] \ || die "offre ${OFFER_NAME} : frais de mise en service non nuls ($(money '.fee' <<< "${OFFER}")), refus" - printf '%s\n' "${OFFER}" + jq -c --arg z "${ZONE}" '. + {zone: $z}' <<< "${OFFER}" } resolve_os () { @@ -164,11 +175,18 @@ build_request () { } lab_servers () { - local JSON - JSON=$(api GET "/baremetal/v1/zones/${ZONE}/servers?project_id=${PROJECT_ID}&tags=${LAB_TAG}&page_size=100") \ - || return 1 - jq -c --arg p "${PROJECT_ID}" --arg t "${LAB_TAG}" \ - '[.servers[] | select(.project_id == $p and (.tags | index($t)))]' <<< "${JSON}" + local JSON Z ALL="[]" RC=0 + for Z in ${ZONES}; do + if ! JSON=$(api GET "/baremetal/v1/zones/${Z}/servers?project_id=${PROJECT_ID}&tags=${LAB_TAG}&page_size=100"); then + warn "zone ${Z} : liste des serveurs de lab indisponible" + RC=1 + continue + fi + ALL=$(jq -c --argjson all "${ALL}" --arg p "${PROJECT_ID}" --arg t "${LAB_TAG}" --arg z "${Z}" \ + '$all + [.servers[] | select(.project_id == $p and (.tags | index($t))) | . + {zone: $z}]' <<< "${JSON}") + done + printf '%s\n' "${ALL}" + return "${RC}" } server_ip () { @@ -180,12 +198,26 @@ server_is_installing () { or (.install.status // "") == "to_install" or (.install.status // "") == "installing"' >/dev/null } +select_zone () { + local Z OUT + for Z in ${ZONES}; do + if OUT=$(ZONE="${Z}" resolve_offer 2>&1); then + printf '%s\n' "${OUT}" + return 0 + fi + warn "${Z} : ${OUT##*!! }" + done + die "offre horaire ${OFFER_NAME} disponible dans aucune zone candidate (${ZONES})" +} + cmd_plan () { local OFFER OS KEYS - OFFER=$(resolve_offer) || exit 1 + OFFER=$(select_zone) || exit 1 + ZONE=$(jq -r '.zone' <<< "${OFFER}") OS=$(resolve_os "$(jq -r '.id' <<< "${OFFER}")") || exit 1 KEYS=$(resolve_ssh_keys) || exit 1 - info "offre : ${OFFER_NAME} ($(jq -r '.id' <<< "${OFFER}")), facturation $(jq -r '.subscription_period' <<< "${OFFER}"), stock $(jq -r '.stock' <<< "${OFFER}")" + info "zone : ${ZONE}" + info "offre : ${OFFER_NAME} ($(jq -r '.id' <<< "${OFFER}")), $(jq -r '[.cpus[]?.name] | unique | join(", ") | if . == "" then "CPU ?" else . end' <<< "${OFFER}"), facturation $(jq -r '.subscription_period' <<< "${OFFER}"), stock $(jq -r '.stock' <<< "${OFFER}")" info "prix : $(money '.price_per_hour' <<< "${OFFER}") HT par heure, frais de mise en service $(money '.fee' <<< "${OFFER}")" info "os : $(jq -r '"\(.name) \(.version) (\(.id))"' <<< "${OS}"), utilisateur $(jq -r '.user.default_value // "?"' <<< "${OS}")" info "clés : $(jq -r 'length' <<< "${KEYS}") clé(s) SSH du projet" @@ -251,7 +283,8 @@ require_no_lab_server () { report_uncertain_creation () { local FOUND - if FOUND=$(lab_servers) && [[ $(jq 'length' <<< "${FOUND}") -gt 0 ]]; then + FOUND=$(lab_servers) + if [[ $(jq 'length' <<< "${FOUND}") -gt 0 ]]; then warn "un serveur de lab existe bien : $(jq -r '[.[].id] | join(", ")' <<< "${FOUND}")" fi die "création incertaine : le serveur a pu être créé et être facturé ; '${0##*/} status' puis '${0##*/} down'" @@ -260,15 +293,16 @@ report_uncertain_creation () { cmd_up () { local OFFER OS KEYS BODY JSON ID IP SSH_USER require_no_lab_server - OFFER=$(resolve_offer) || exit 1 + OFFER=$(select_zone) || exit 1 + ZONE=$(jq -r '.zone' <<< "${OFFER}") OS=$(resolve_os "$(jq -r '.id' <<< "${OFFER}")") || exit 1 KEYS=$(resolve_ssh_keys) || exit 1 BODY=$(build_request "${OFFER}" "${OS}" "${KEYS}") - info "création de ${LAB_NAME} (${OFFER_NAME}, $(money '.price_per_hour' <<< "${OFFER}")/h HT)" + info "création de ${LAB_NAME} (${OFFER_NAME}, ${ZONE}, $(money '.price_per_hour' <<< "${OFFER}")/h HT)" JSON=$(api POST "/baremetal/v1/zones/${ZONE}/servers" "${BODY}") || report_uncertain_creation ID=$(jq -r '.id // empty' <<< "${JSON}" 2>/dev/null) [[ -n "${ID}" ]] || report_uncertain_creation - CREATED_ID="${ID}" + CREATED_ID="${ZONE} ${ID}" info "serveur ${ID} créé, facturé jusqu'à '${0##*/} down'" JSON=$(wait_installed "${ID}") || die "serveur ${ID} inutilisable — il est toujours facturé : '${0##*/} down'" IP=$(server_ip <<< "${JSON}") @@ -283,13 +317,14 @@ cmd_up () { } cmd_status () { - local SERVERS - SERVERS=$(lab_servers) || die "impossible de lister les serveurs de lab" + local SERVERS RC=0 + SERVERS=$(lab_servers) || RC=1 if [[ $(jq 'length' <<< "${SERVERS}") -eq 0 ]]; then - info "aucun serveur de lab dans le projet ${PROJECT_ID} (${ZONE})" - return 0 + [[ "${RC}" -eq 0 ]] && info "aucun serveur de lab dans le projet ${PROJECT_ID} (${ZONES})" + else + jq -r '.[] | "\(.zone) \(.id) \(.name) \(.offer_name) \(.status) installation \(.install.status // "none") \(.created_at) \([.ips[] | select(.version == "IPv4") | .address] | join(","))"' <<< "${SERVERS}" fi - jq -r '.[] | "\(.id) \(.name) \(.offer_name) \(.status) installation \(.install.status // "none") \(.created_at) \([.ips[] | select(.version == "IPv4") | .address] | join(","))"' <<< "${SERVERS}" + [[ "${RC}" -eq 0 ]] || die "liste incomplète : des serveurs de lab peuvent exister dans les zones en erreur" } require_known_server () { @@ -319,13 +354,18 @@ case "${NESTED}" in Y|1) ;; *) echo "virtualisation imbriquée désactivée (nested=${NESTED:-absent})" >&2; exit 1 ;; esac -echo "qemu $(qemu-system-x86_64 --version | head -n 1), nested=${NESTED}" +LD=$(ls /lib64/ld-linux-x86-64.so.2 /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 2>/dev/null | head -n 1) +if ! "${LD}" --help 2>/dev/null | grep -q 'x86-64-v3 (supported'; then + echo "CPU sans x86-64-v3 :$(grep -m 1 'model name' /proc/cpuinfo | cut -d: -f2) — Rocky 10 / RHEL 10 n'y démarrent pas" >&2 + exit 1 +fi +echo "qemu $(qemu-system-x86_64 --version | head -n 1), nested=${NESTED},$(grep -m 1 'model name' /proc/cpuinfo | cut -d: -f2)" EOF } cmd_prepare () { require_known_server - info "préparation du serveur : qemu, genisoimage, KVM imbriqué" + info "préparation du serveur : qemu, genisoimage, KVM imbriqué, CPU x86-64-v3" prepare_script | ssh_run -- bash -s } @@ -390,28 +430,29 @@ wait_gone () { lab_server_ids () { local DEADLINE=$(( SECONDS + DELETE_TIMEOUT )) - local SERVERS + local SERVERS="[]" while (( SECONDS < DEADLINE )); do if SERVERS=$(lab_servers); then - jq -r '.[].id' <<< "${SERVERS}" + jq -r '.[] | "\(.zone) \(.id)"' <<< "${SERVERS}" return 0 fi - warn "liste des serveurs de lab indisponible, nouvel essai dans ${POLL_INTERVAL}s" + warn "liste des serveurs de lab incomplète, nouvel essai dans ${POLL_INTERVAL}s" sleep "${POLL_INTERVAL}" done + jq -r '.[] | "\(.zone) \(.id)"' <<< "${SERVERS}" return 1 } cmd_down () { local IDS ID FAILED=0 if ! IDS=$(lab_server_ids); then - warn "impossible de lister les serveurs de lab après ${DELETE_TIMEOUT}s" + warn "liste des serveurs de lab incomplète après ${DELETE_TIMEOUT}s : suppression de ceux qui sont listés" FAILED=1 - IDS="" fi IDS=$(printf '%s\n%s\n' "${IDS}" "${CREATED_ID}" | grep -v '^$' | sort -u) - for ID in ${IDS}; do - info "suppression de ${ID}" + while read -r ZONE ID; do + [[ -n "${ID}" ]] || continue + info "suppression de ${ID} (${ZONE})" if ! delete_server "${ID}"; then warn "suppression de ${ID} toujours refusée" FAILED=1 @@ -421,7 +462,7 @@ cmd_down () { warn "${ID} toujours présent après ${DELETE_TIMEOUT}s" FAILED=1 fi - done + done <<< "${IDS}" rm -f "${STATE_DIR}/ip" "${STATE_DIR}/user" "${STATE_DIR}/known_hosts" [[ "${FAILED}" -eq 0 ]] || die "SERVEUR(S) DE LAB TOUJOURS FACTURÉ(S) — '${0##*/} status', puis la console Scaleway" info "aucun serveur de lab ne reste dans le projet" diff --git a/scripts/lab-host_test.sh b/scripts/lab-host_test.sh index 9953579..8e8d848 100755 --- a/scripts/lab-host_test.sh +++ b/scripts/lab-host_test.sh @@ -63,18 +63,22 @@ with open(os.path.join(d, "calls.log"), "a") as f: if "X-Auth-Token: " + os.environ["FAKE_SECRET"] not in headers: reply(401, {"message": "unauthorized"}) -zone = "/baremetal/v1/zones/fr-par-1" +zname = path.split("/")[4] if path.startswith("/baremetal/v1/zones/") else "" +zone = "/baremetal/v1/zones/" + zname if method == "GET" and path == zone + "/offers": - reply(200, {"offers": st["offers"], "total_count": len(st["offers"])}) + offers = st.get("zones", {}).get(zname, {}).get("offers", st["offers"] if zname == "fr-par-1" else []) + reply(200, {"offers": offers, "total_count": len(offers)}) if method == "GET" and path == zone + "/os": reply(200, {"os": st["os"], "total_count": len(st["os"])}) if method == "GET" and path == "/iam/v1alpha1/ssh-keys": reply(200, {"ssh_keys": st["keys"], "total_count": len(st["keys"])}) if method == "GET" and path == zone + "/servers": + if st.get("zones", {}).get(zname, {}).get("list_fail"): + reply(503, {"message": "service unavailable"}) if st["list_errors"] > 0: st["list_errors"] -= 1 reply(503, {"message": "service unavailable"}) - listed = [v for v in st["servers"].values() if not v.get("hidden")] + listed = [v for v in st["servers"].values() if not v.get("hidden") and v.get("zone", "fr-par-1") == zname] reply(200, {"servers": listed, "total_count": len(listed)}) if method == "POST" and path == zone + "/servers": req = json.loads(body) @@ -84,7 +88,7 @@ if method == "POST" and path == zone + "/servers": sid = "srv-%d" % st["seq"] st["servers"][sid] = {"id": sid, "name": req["name"], "project_id": req["project_id"], "tags": req["tags"], "offer_name": "EM-B212X-SSD", "status": "delivering", - "install": {"status": "to_install"}, "ips": [], "created_at": "now", + "install": {"status": "to_install"}, "ips": [], "created_at": "now", "zone": zname, "hidden": st["hide_from_list"]} if st["post_fail_after_create"]: reply(502, {"message": "bad gateway"}) @@ -93,7 +97,7 @@ if method == "POST" and path == zone + "/servers": reply(200, st["servers"][sid]) if path.startswith(zone + "/servers/"): sid = path.rsplit("/", 1)[1] - if sid not in st["servers"]: + if sid not in st["servers"] or st["servers"][sid].get("zone", "fr-par-1") != zname: reply(404, {"message": "not found"}) srv = st["servers"][sid] if method == "GET" and st["get_errors"] > 0: @@ -222,7 +226,8 @@ lab_env () { SCW_API_URL="https://api.example.invalid" SCW_SECRET_KEY="${SECRET}" \ SCW_DEFAULT_PROJECT_ID="${PROJECT}" LAB_POLL_INTERVAL="${LAB_POLL_INTERVAL:-0}" \ LAB_INSTALL_TIMEOUT="${LAB_INSTALL_TIMEOUT:-60}" LAB_DELETE_TIMEOUT="${LAB_DELETE_TIMEOUT:-60}" \ - LAB_SSH_TIMEOUT="${LAB_SSH_TIMEOUT:-60}" \ + LAB_SSH_TIMEOUT="${LAB_SSH_TIMEOUT:-60}" LAB_ZONES="${LAB_ZONES:-fr-par-1}" \ + LAB_OFFER="${LAB_OFFER:-EM-B212X-SSD}" ${SCW_DEFAULT_ZONE:+SCW_DEFAULT_ZONE="${SCW_DEFAULT_ZONE}"} \ "$@" } @@ -467,6 +472,33 @@ test_down_fails_loudly_when_listing_never_works () { teardown } +test_down_deletes_what_answering_zones_list_when_one_zone_fails () { + setup "down : une zone en erreur n'empêche pas de supprimer les serveurs des autres" + mutate ".servers[\"srv-lab\"] = ${LAB_SERVER} | .zones = {\"nl-ams-2\": {list_fail: true}}" + LAB_ZONES="fr-par-1 nl-ams-2" LAB_DELETE_TIMEOUT=1 run_lab down && fail "down a réussi malgré une zone en erreur" + [[ $(remaining) == "foreign-1,foreign-2" ]] || fail "restants : $(remaining)" + grep -q "zone nl-ams-2" "${WORK}/out.log" || fail "zone en erreur non signalée" + grep -q "TOUJOURS FACTURÉ" "${WORK}/out.log" || fail "pas d'alerte de facturation" + teardown +} + +test_status_lists_answering_zones_and_fails_when_one_zone_fails () { + setup "status : liste les zones qui répondent, échoue si une zone est en erreur" + mutate ".servers[\"srv-lab\"] = ${LAB_SERVER} | .zones = {\"nl-ams-2\": {list_fail: true}}" + LAB_ZONES="fr-par-1 nl-ams-2" run_lab status && fail "status a réussi malgré une zone en erreur" + grep -q "^fr-par-1 srv-lab " "${WORK}/out.log" || fail "srv-lab non listé" + grep -q "liste incomplète" "${WORK}/out.log" || fail "liste incomplète non signalée" + teardown +} + +test_up_refuses_when_one_zone_cannot_be_listed () { + setup "up : refus si une zone ne peut pas être listée" + mutate '.zones = {"nl-ams-2": {list_fail: true}} | .progress = [["ready","completed"]]' + LAB_ZONES="fr-par-1 nl-ams-2" run_lab up && fail "up a réussi" + grep -q "^POST" "${WORK}/calls.log" && fail "serveur créé sans connaître toutes les zones" + teardown +} + test_session_deletes_created_server_even_if_missing_from_list () { setup "session : supprime le serveur créé même absent de la liste" mutate '.hide_from_list = true | .progress = [["ready","completed"]]' @@ -730,7 +762,7 @@ test_ssh_without_terminal_does_not_ask_for_one () { run_lab_without_env_credentials () { env -i PATH="${WORK}/bin:${PATH}" HOME="${WORK}" TMPDIR="${TMPDIR:-/tmp}" \ FAKE_DIR="${WORK}" FAKE_SECRET="${SECRET}" SCW_API_URL="https://api.example.invalid" \ - LAB_POLL_INTERVAL=0 "$@" bash "${SCRIPT}" plan > "${WORK}/out.log" 2>&1 + LAB_POLL_INTERVAL=0 LAB_ZONES=fr-par-1 LAB_OFFER=EM-B212X-SSD "$@" bash "${SCRIPT}" plan > "${WORK}/out.log" 2>&1 } write_credentials () { @@ -814,6 +846,74 @@ signal_during_session () { teardown } +zone_offer () { + jq -n --arg id "${1}" --arg stock "${2}" '{id: $id, name: "EM-B420E-NVME", subscription_period: "hourly", enable: true, + stock: $stock, cpus: [{name: "AMD EPYC 7272"}], price_per_hour: {currency_code: "EUR", units: 0, nanos: 444000000}, + fee: {currency_code: "EUR", units: 0, nanos: 0}}' +} + +test_default_offer_is_the_epyc_one () { + setup "offre par défaut : EM-B420E-NVME" + LAB_OFFER=EM-B420E-NVME run_lab plan + grep -q 'aucune zone candidate' "${WORK}/out.log" || fail "l'offre EM-B420E-NVME n'a pas été cherchée" + grep -q 'name=EM-B420E-NVME' "${WORK}/calls.log" || fail "requête : $(cat "${WORK}/calls.log")" + [[ $(env -i bash -c ". '${SCRIPT}'; echo \${OFFER_NAME}") == EM-B420E-NVME ]] \ + || fail "défaut lu : $(env -i bash -c ". '${SCRIPT}'; echo \${OFFER_NAME}")" + teardown +} + +test_up_takes_the_first_zone_with_stock () { + setup "up : première zone candidate où l'offre est en stock" + mutate ".zones = {\"fr-par-2\": {offers: [$(zone_offer off-par2 empty)]}, \"nl-ams-2\": {offers: [$(zone_offer off-ams2 available)]}} + | .progress = [[\"ready\", \"completed\"]]" + LAB_ZONES="fr-par-2 nl-ams-2 pl-waw-3" LAB_OFFER=EM-B420E-NVME run_lab up + grep -q 'POST /baremetal/v1/zones/nl-ams-2/servers' "${WORK}/calls.log" || fail "pas de création en nl-ams-2 : $(grep POST "${WORK}/calls.log")" + grep -q 'zones/pl-waw-3/offers' "${WORK}/calls.log" && fail "zone suivante interrogée après avoir trouvé du stock" + [[ $(jq -r '.offer_id' "${WORK}/create.json") == off-ams2 ]] || fail "offre créée : $(jq -c . "${WORK}/create.json")" + grep -q 'fr-par-2 : offre EM-B420E-NVME en rupture de stock' "${WORK}/out.log" || fail "raison du refus de fr-par-2 absente" + teardown +} + +test_preferred_zone_goes_first () { + setup "SCW_DEFAULT_ZONE : préférence placée en tête, sans exclure les autres" + [[ $(lab_env bash -c ". '${SCRIPT}'; candidate_zones nl-ams-2 'fr-par-1 nl-ams-2 pl-waw-3'") == "nl-ams-2 fr-par-1 pl-waw-3" ]] \ + || fail "ordre : $(lab_env bash -c ". '${SCRIPT}'; candidate_zones nl-ams-2 'fr-par-1 nl-ams-2 pl-waw-3'")" + [[ $(lab_env bash -c ". '${SCRIPT}'; candidate_zones '' 'fr-par-1 nl-ams-2'") == "fr-par-1 nl-ams-2" ]] || fail "sans préférence" + teardown +} + +test_no_zone_with_stock_is_refused_without_creation () { + setup "aucune zone en stock : refus, rien n'est créé" + LAB_ZONES="fr-par-2 nl-ams-2" LAB_OFFER=EM-B420E-NVME run_lab up && fail "code de retour nul" + grep -q 'disponible dans aucune zone candidate (fr-par-2 nl-ams-2)' "${WORK}/out.log" || fail "message absent" + grep -q '^POST' "${WORK}/calls.log" && fail "serveur créé" + teardown +} + +test_down_and_status_cover_every_candidate_zone () { + setup "down et status : serveurs de lab de toutes les zones candidates" + mutate ".servers[\"lab-ams\"] = {id: \"lab-ams\", name: \"two-lab\", project_id: \"${PROJECT}\", tags: [\"two-lab\"], + status: \"ready\", install: {status: \"completed\"}, ips: [], zone: \"nl-ams-2\", offer_name: \"EM-B420E-NVME\", created_at: \"now\"}" + mutate ".servers[\"lab-par\"] = {id: \"lab-par\", name: \"two-lab\", project_id: \"${PROJECT}\", tags: [\"two-lab\"], + status: \"ready\", install: {status: \"completed\"}, ips: [], offer_name: \"EM-B212X-SSD\", created_at: \"now\"}" + LAB_ZONES="fr-par-1 nl-ams-2" run_lab status + grep -q '^nl-ams-2 lab-ams' "${WORK}/out.log" || fail "status : $(cat "${WORK}/out.log")" + LAB_ZONES="fr-par-1 nl-ams-2" run_lab down || fail "down en échec" + grep -q 'DELETE /baremetal/v1/zones/nl-ams-2/servers/lab-ams' "${WORK}/calls.log" || fail "lab-ams non supprimé dans sa zone" + [[ $(remaining) == "foreign-1,foreign-2" ]] || fail "restants : $(remaining)" + teardown +} + +test_prepare_script_requires_x86_64_v3 () { + setup "prepare : refus d'un CPU sans x86-64-v3" + local DIR="${WORK}/root" + mkdir -p "${DIR}/bin" "${DIR}/sys/module/kvm_intel/parameters" "${DIR}/dev" + lab_env bash -c ". '${SCRIPT}'; prepare_script" > "${WORK}/prepare.sh" + grep -q "x86-64-v3 (supported" "${WORK}/prepare.sh" || fail "aucune vérification x86-64-v3 dans le script de préparation" + grep -q "exit 1" <<< "$(sed -n '/x86-64-v3/,/fi/p' "${WORK}/prepare.sh")" || fail "pas d'arrêt si le niveau manque" + teardown +} + test_session_handles_term () { signal_during_session TERM 143; } test_session_handles_hup () { signal_during_session HUP 129; } test_session_handles_int () { signal_during_session INT 130; } diff --git a/test/e2e/lib/node.sh b/test/e2e/lib/node.sh index 0a7111c..b424c98 100644 --- a/test/e2e/lib/node.sh +++ b/test/e2e/lib/node.sh @@ -26,6 +26,10 @@ api_delete () { curl -fsS -o /dev/null -X DELETE "${API}/${1}" } +api_code () { + curl -s -o /dev/null -w '%{http_code}' -X "${1}" "${API}/${2}" +} + api_state () { curl -fsS "${API}/${1}" 2>/dev/null | jq -r .state } @@ -44,8 +48,9 @@ wait_state () { } vpc_create () { + local l3vni="${3:+,\"l3vni\":${3}}" api_state "vpcs/${1}" | grep -qx running && return 0 - api_post vpcs "{\"name\":\"${1}\",\"cidr\":\"${2}\"}" && wait_state "vpcs/${1}" running + api_post vpcs "{\"name\":\"${1}\",\"cidr\":\"${2}\"${l3vni}}" && wait_state "vpcs/${1}" running } subnet_create () { @@ -83,6 +88,7 @@ vm_key () { vm_create () { local name="${1}" subnet="${2}" ip="${3}" key="${4:-}" meta="{}" + api_state "vms/${name}" | grep -qx running && return 0 [ -n "${key}" ] && meta="{\"sshkey\":\"${key}\"}" mkdir -p "${VOLUMES}" cp "${TWO_IMAGE}" "${VOLUMES}/${name}.qcow2" || return 1 @@ -149,3 +155,105 @@ state = json.loads(buf).get("state") or {} print(" ".join(sorted(h["mac"].lower() + "=" + h["ip"] for h in state.get("hosts") or []))) PY } + +vrf_nexthops () { + ip -4 route show vrf "vrf-${1#vp-}" "${2}" | grep -o 'via [0-9.]*' | cut -d' ' -f2 | sort -u | tr '\n' ' ' | sed 's/ $//' +} + +wait_vrf_nexthops () { + local i + for i in $(seq 1 30); do + [ "$(vrf_nexthops "${1}" "${2}")" = "${3}" ] && return 0 + sleep 2 + done + echo "vrf-${1#vp-} ${2} : next-hops « $(vrf_nexthops "${1}" "${2}") », « ${3} » attendu" >&2 + return 1 +} + +ping_rate () { + vm_ssh "${1}" "${2}" "ping -q -n -c ${4:-50} -i 0.2 -W 1 ${3}" 2>/dev/null | grep -o '[0-9]* received' | cut -d' ' -f1 +} + +vrf_route_via () { + ip -4 route show vrf "vrf-${1#vp-}" "${2}" | grep -q "via ${3} " +} + +wait_vrf_route () { + local i + for i in $(seq 1 30); do + vrf_route_via "$@" && return 0 + sleep 2 + done + echo "vrf-${1#vp-} : pas de route ${2} via ${3}" >&2 + return 1 +} + +vrf_members () { + ip -o link show master "vrf-${1#vp-}" | awk -F': ' '{print $2}' | cut -d@ -f1 | sort | tr '\n' ' ' | sed 's/ $//' +} + +netns_ping_wait () { + local i + for i in $(seq 1 40); do + ip netns exec "${1}" ping -c 1 -W 2 "${2}" >/dev/null 2>&1 && return 0 + sleep 5 + done + echo "${2} injoignable depuis ${1}" >&2 + return 1 +} + +l3vni_ready () { + local out + out=$(vtysh -c "show evpn vni ${1}") && + grep -q 'Type: L3' <<<"${out}" && + grep -q 'State: Up' <<<"${out}" && + grep -qi "Router MAC: ${2}" <<<"${out}" +} + +wait_l3vni () { + local i + for i in $(seq 1 15); do + l3vni_ready "$@" && return 0 + sleep 2 + done + echo "VNI ${1} : pas de type L3 actif avec la RMAC ${2}" >&2 + return 1 +} + +vtep_host () { + ip -4 route get 10.255.255.1 | grep -o 'src [0-9.]*' | cut -d' ' -f2 +} + +bgp_paths () { + vtysh -c "show bgp vrf vrf-${1#vp-} ipv4 unicast ${2} json" 2>/dev/null | jq -r '(.paths // []) | length' +} + +bgp_best () { + vtysh -c "show bgp vrf vrf-${1#vp-} ipv4 unicast ${2} json" 2>/dev/null | + jq -r '(.paths // [])[] | select(.bestpath.overall == true) | "\(.nexthops[0].ip) (\(.bestpath.selectionReason // "seul chemin"))"' +} + +sources_reach () { + local vpc="${1}" bridge="${2}" base="${3}" dst="${4}" n ok=0 total=0 + for n in $(seq 20 59); do + ip -n "${vpc}" addr add "${base}.${n}/32" dev "${bridge}" 2>/dev/null + ip netns exec "${vpc}" ping -n -c 2 -W 1 -I "${base}.${n}" "${dst}" >/dev/null 2>&1 && ok=$((ok + 1)) + total=$((total + 1)) + ip -n "${vpc}" addr del "${base}.${n}/32" dev "${bridge}" + done + echo "${ok}/${total}" +} + +watchdog_reported () { + journalctl -u agent --since "-${2:-120}s" --no-pager -o cat | grep -F 'watchdog: inconsistency detected' | grep -qF -- "${1}" +} + +wait_watchdog () { + local i + for i in $(seq 1 30); do + watchdog_reported "$@" && return 0 + sleep 2 + done + echo "watchdog : « ${1} » non signalé" >&2 + return 1 +} diff --git a/test/e2e/run_test.sh b/test/e2e/run_test.sh index dd8022f..26393a9 100755 --- a/test/e2e/run_test.sh +++ b/test/e2e/run_test.sh @@ -133,6 +133,84 @@ test_wait_state () { teardown } +test_vrf_route_via_matches_the_next_hop_exactly () { + setup "vrf_route_via : next-hop exact dans la bonne VRF" + local stub='ip () { [ "$*" = "-4 route show vrf vrf-s7 10.241.1.10" ] && echo "10.241.1.10 nhid 12 via 192.168.14.11 dev brl3-s7 proto bgp metric 20 onlink"; }; ' + [[ $(node "${stub}vrf_route_via vp-s7 10.241.1.10 192.168.14.11 && echo OUI") == OUI ]] || fail "route présente refusée" + [[ $(node "${stub}vrf_route_via vp-s7 10.241.1.10 192.168.14.1 || echo NON") == NON ]] || fail "192.168.14.1 pris pour 192.168.14.11" + [[ $(node "${stub}vrf_route_via vp-s7b 10.241.1.10 192.168.14.11 || echo NON") == NON ]] || fail "mauvaise VRF acceptée" + teardown +} + +test_vrf_members_lists_interface_names () { + setup "vrf_members : noms triés, sans le suffixe @ du veth" + [[ $(node 'ip () { printf "%s\n" "15: l3-s7-o@if14: mtu 1500 master vrf-s7" "12: brl3-s7: mtu 1500 master vrf-s7"; }; vrf_members vp-s7') == "brl3-s7 l3-s7-o" ]] \ + || fail "lu : $(node 'ip () { printf "%s\n" "15: l3-s7-o@if14: " "12: brl3-s7: "; }; vrf_members vp-s7')" + teardown +} + +test_vm_create_is_idempotent () { + setup "vm_create : VM déjà en running, rien n'est copié ni envoyé" + [[ $(node 'api_state () { echo running; }; cp () { echo COPIE; }; api_post () { echo POST; }; vm_create v sn 10.0.0.10 && echo OK') == OK ]] \ + || fail "VM existante recréée" + teardown +} + +test_l3vni_ready_requires_type_state_and_rmac () { + setup "l3vni_ready : type L3, état Up et RMAC exigés" + local out='VNI: 2700\n Type: L3\n State: Up\n Router MAC: 02:00:00:00:27:02' + [[ $(node "vtysh () { printf '${out}\n'; }; l3vni_ready 2700 02:00:00:00:27:02 && echo OUI") == OUI ]] || fail "VNI prête refusée" + [[ $(node "vtysh () { printf '${out}\n'; }; l3vni_ready 2700 02:00:00:00:27:01 || echo NON") == NON ]] || fail "mauvaise RMAC acceptée" + [[ $(node "vtysh () { printf '${out/Up/Down}\n'; }; l3vni_ready 2700 02:00:00:00:27:02 || echo NON") == NON ]] || fail "état Down accepté" + [[ $(node "vtysh () { printf '${out/L3/L2}\n'; }; l3vni_ready 2700 02:00:00:00:27:02 || echo NON") == NON ]] || fail "VNI L2 acceptée" + teardown +} + +test_vrf_nexthops_lists_every_ecmp_member () { + setup "vrf_nexthops : un chemin, plusieurs chemins, aucun" + [[ $(node 'ip () { echo "10.242.1.50 nhid 9 via 192.168.14.12 dev brl3-s8 proto bgp metric 20 onlink"; }; vrf_nexthops vp-s8 10.242.1.50') == 192.168.14.12 ]] || fail "un chemin" + [[ $(node 'ip () { printf "%s\n" "10.242.1.0/24 nhid 90 proto bgp metric 20" " nexthop via 192.168.14.12 dev brl3-s8 weight 1 onlink" " nexthop via 192.168.14.11 dev brl3-s8 weight 1 onlink"; }; vrf_nexthops vp-s8 10.242.1.0/24') == "192.168.14.11 192.168.14.12" ]] || fail "ECMP" + [[ -z $(node 'ip () { :; }; vrf_nexthops vp-s8 10.242.1.50') ]] || fail "aucun chemin" + teardown +} + +test_bgp_best_reports_next_hop_and_reason () { + setup "bgp_paths / bgp_best : nombre de chemins, meilleur next-hop et raison" + local json='{"prefix":"10.242.1.50/32","paths":[{"nexthops":[{"ip":"192.168.14.12"}]},{"nexthops":[{"ip":"192.168.14.11"}],"bestpath":{"overall":true,"selectionReason":"Router ID"}}]}' + [[ $(node "vtysh () { echo '${json}'; }; bgp_paths vp-s8 10.242.1.50/32") == 2 ]] || fail "nombre de chemins" + [[ $(node "vtysh () { echo '${json}'; }; bgp_best vp-s8 10.242.1.50/32") == "192.168.14.11 (Router ID)" ]] || fail "meilleur : $(node "vtysh () { echo '${json}'; }; bgp_best vp-s8 10.242.1.50/32")" + [[ $(node "vtysh () { echo '{}'; }; bgp_paths vp-s8 10.242.1.50/32") == 0 ]] || fail "préfixe absent" + teardown +} + +test_vpc_create_sends_the_l3vni_only_when_given () { + setup "vpc_create : l3vni transmise si donnée, absente sinon" + local stub='api_state () { echo; }; wait_state () { :; }; api_post () { echo "$1 $2"; }; ' + [[ $(node "${stub}vpc_create vp-s7 10.241.0.0/16 2700") == 'vpcs {"name":"vp-s7","cidr":"10.241.0.0/16","l3vni":2700}' ]] \ + || fail "avec l3vni : $(node "${stub}vpc_create vp-s7 10.241.0.0/16 2700")" + [[ $(node "${stub}vpc_create vp-s1 10.210.0.0/16") == 'vpcs {"name":"vp-s1","cidr":"10.210.0.0/16"}' ]] \ + || fail "sans l3vni : $(node "${stub}vpc_create vp-s1 10.210.0.0/16")" + teardown +} + +test_api_code_returns_the_http_status () { + setup "api_code : méthode, chemin et code HTTP" + [[ $(node 'curl () { echo "$*" >&2; echo 409; }; api_code DELETE subnets/sn-a 2>/dev/null') == 409 ]] || fail "code" + [[ $(node 'curl () { echo "$*"; }; api_code DELETE subnets/sn-a') == "-s -o /dev/null -w %{http_code} -X DELETE http://127.0.0.1:8080/subnets/sn-a" ]] \ + || fail "appel : $(node 'curl () { echo "$*"; }; api_code DELETE subnets/sn-a')" + teardown +} + +test_watchdog_reported_matches_only_watchdog_alerts () { + setup "watchdog_reported : alerte du watchdog contenant le texte, rien d'autre" + local alert='{"level":"ERROR","msg":"watchdog: inconsistency detected","kind":"vpc","name":"vp-s8","problem":"route 10.242.1.99/32 exported in vrf-s8 without a running owner: its traffic is black-holed"}' + local other='{"level":"ERROR","msg":"command failed","error":"route 10.242.1.99/32 exported in vrf-s8 without a running owner"}' + [[ $(node "journalctl () { echo '${alert}'; }; watchdog_reported 'route 10.242.1.99/32 exported in vrf-s8 without a running owner' && echo OUI") == OUI ]] || fail "alerte non trouvée" + [[ $(node "journalctl () { echo '${other}'; }; watchdog_reported 'route 10.242.1.99/32 exported in vrf-s8' || echo NON") == NON ]] || fail "message hors watchdog accepté" + [[ $(node "journalctl () { echo '${alert}'; }; watchdog_reported 'route 10.242.1.98/32' || echo NON") == NON ]] || fail "autre route acceptée" + teardown +} + for T in $(declare -F | awk '{print $3}' | grep '^test_'); do "${T}" done diff --git a/test/e2e/scenarios/s7-l3vni.sh b/test/e2e/scenarios/s7-l3vni.sh new file mode 100644 index 0000000..22b02cc --- /dev/null +++ b/test/e2e/scenarios/s7-l3vni.sh @@ -0,0 +1,73 @@ +on hv1 <<'NODE' +two_image || { echo "ÉCHOUÉ: image compatible two (hv1)"; exit 0; } +KEY=$(vm_key) +check "hv1 : base BGP posée par l'agent et enregistrée dans frr.conf" grep -qx ' neighbor 10.255.255.1 peer-group fabric' /etc/frr/frr.conf +check "hv1 : VPC vp-s7, l3vni 2700" vpc_create vp-s7 10.241.0.0/16 2700 +check "hv1 : subnet sn-s7d (VNI 2711), seulement sur hv1" subnet_create sn-s7d vp-s7 2711 10.241.1.1 10.241.1.0/24 +check "hv1 : VM s7-a" vm_create s7-a sn-s7d 10.241.1.10 "${KEY}" +NODE +on hv2 <<'NODE' +two_image || { echo "ÉCHOUÉ: image compatible two (hv2)"; exit 0; } +check "hv2 : VPC vp-s7, l3vni 2700" vpc_create vp-s7 10.241.0.0/16 2700 +check "hv2 : subnet sn-s7e (VNI 2712), seulement sur hv2" subnet_create sn-s7e vp-s7 2712 10.241.2.1 10.241.2.0/24 +check "hv2 : VM s7-b" vm_create s7-b sn-s7e 10.241.2.10 +check "hv2 : VPC vp-s7b, même plage, l3vni 2701" vpc_create vp-s7b 10.241.0.0/16 2701 +check "hv2 : subnet sn-s7x (VNI 2713), même plage que sn-s7e" subnet_create sn-s7x vp-s7b 2713 10.241.2.1 10.241.2.0/24 +check "hv2 : VM s7-x dans vp-s7b" vm_create s7-x sn-s7x 10.241.2.20 +check "hv2 : l3vni 2700 déjà prise par vp-s7, refusée (409)" test "$(curl -s -o /dev/null -w '%{http_code}' -X POST -H 'Content-Type: application/json' -d '{"name":"vp-s7c","cidr":"10.249.0.0/16","l3vni":2700}' "${API}/vpcs")" = 409 +NODE +on hv1 <<'NODE' +check "s7-a joignable" vm_wait vp-s7 10.241.1.10 +check "s7-a : route vers la VPC 10.241.0.0/16 via interface_ip (DHCP)" route_via vp-s7 10.241.1.10 10.241.0.0/16 10.241.1.1 +check "hv1 : vrf-s7 contient exactement brl3-s7 et l3-s7-o" sh -c "[ \"\$1\" = 'brl3-s7 l3-s7-o' ]" _ "$(vrf_members vp-s7)" +check "hv1 : brl3-s7 sans adresse IPv4" sh -c "! ip -4 -o addr show dev brl3-s7 | grep -q inet" +check "hv1 : RMAC de brl3-s7 dérivée du VTEP 192.168.14.11" sh -c "ip -o link show brl3-s7 | grep -q 'link/ether 02:02:c0:a8:0e:0b '" +check "hv1 : route du supernet dans vp-s7 vers le transit" sh -c "ip -n vp-s7 -4 route show 10.241.0.0/16 | grep -q 'via 169.254.0.1 dev l3-s7-i'" +check "hv1 : forwarding sur brl3-s7 et l3-s7-o" sh -c "[ \"\$(sysctl -n net.ipv4.conf.brl3-s7.forwarding net.ipv4.conf.l3-s7-o.forwarding | tr '\n' ' ')\" = '1 1 ' ]" +check "hv1 : ip_forward dans le netns vp-s7" sh -c "[ \"\$(ip netns exec vp-s7 sysctl -n net.ipv4.ip_forward)\" = 1 ]" +info "hv1 : ip_forward global de l'hôte : $(sysctl -n net.ipv4.ip_forward) (non modifié par l'agent)" +check "hv1 : vrf-s7 exporte le subnet local 10.241.1.0/24 (agent)" vrf_route_via vp-s7 10.241.1.0/24 169.254.0.2 +check "hv1 : vrf-s7 exporte s7-a 10.241.1.10/32 (agent)" vrf_route_via vp-s7 10.241.1.10 169.254.0.2 +check "hv1 : session vers le RR en iBGP (internal link)" sh -c "vtysh -c 'show bgp neighbors 10.255.255.1' | grep -q 'internal link'" +NODE +on hv2 <<'NODE' +check "hv2 : s7-b joignable depuis son netns" netns_ping_wait vp-s7 10.241.2.10 +check "hv2 : s7-x joignable depuis son netns (témoin)" netns_ping_wait vp-s7b 10.241.2.20 +check "hv2 : VNI 2700 de type L3, active, RMAC 02:02:c0:a8:0e:0c" wait_l3vni 2700 02:02:c0:a8:0e:0c +check "hv2 : VNI 2701 de type L3, active, RMAC 02:02:c0:a8:0e:0c" wait_l3vni 2701 02:02:c0:a8:0e:0c +check "hv2 : vrf-s7 apprend 10.241.1.10/32 via le VTEP de hv1" wait_vrf_route vp-s7 10.241.1.10 192.168.14.11 +check "hv2 : vrf-s7 apprend 10.241.1.0/24 via le VTEP de hv1" wait_vrf_route vp-s7 10.241.1.0/24 192.168.14.11 +check "hv2 : RMAC de hv1 dans la FDB de vxl3-s7" sh -c "bridge fdb show dev vxl3-s7 | grep -q '02:02:c0:a8:0e:0b dst 192.168.14.11'" +NODE +on rr1 <<'NODE' +check "rr1 : RT-5 10.241.1.10/32 de hv1 (RD 192.168.14.11:2700) reçue et réfléchie" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.11:2700 type prefix' | grep -q '\[10.241.1.10\]'" +check "rr1 : RT-5 10.241.2.20/32 de vp-s7b (RD 192.168.14.12:2701) présente (témoin du test négatif)" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.12:2701 type prefix' | grep -q '\[10.241.2.20\]'" +NODE +on hv1 <<'NODE' +check "hv1 : VNI 2700 de type L3, active, RMAC 02:02:c0:a8:0e:0b" wait_l3vni 2700 02:02:c0:a8:0e:0b +check "hv1 : vrf-s7 apprend 10.241.2.10/32 via le VTEP de hv2" wait_vrf_route vp-s7 10.241.2.10 192.168.14.12 +check "hv1 : aucun VXLAN de sn-s7e (VNI 2712) sur hv1" sh -c "! ip link show vxlan-2712 >/dev/null 2>&1" +for i in $(seq 1 24); do vm_ssh vp-s7 10.241.1.10 'ping -c 1 -W 2 10.241.2.10' >/dev/null 2>&1 && break; sleep 5; done +check "s7-a (sn-s7d, hv1) joint s7-b (sn-s7e, hv2) par le L3VNI, forwarding par interface" vm_ssh vp-s7 10.241.1.10 'ping -c 3 -W 2 10.241.2.10' +check "trame pleine taille : 1472 octets en -M do" vm_ssh vp-s7 10.241.1.10 'ping -M do -s 1472 -c 2 -W 2 10.241.2.10' +check "1473 octets refusés localement (MTU 1500)" vm_grep vp-s7 10.241.1.10 'ping -M do -s 1473 -c 1 -W 2 10.241.2.10' 'message too long' +check "TTL 1 : expire à la gateway du subnet, netns de hv1 (10.241.1.1)" vm_grep vp-s7 10.241.1.10 'ping -n -c 3 -i 1.2 -W 2 -t 1 10.241.2.10' 'From 10.241.1.1 .*exceeded' +check "TTL 2 : expire dans la VRF de hv1 (169.254.0.1)" vm_grep vp-s7 10.241.1.10 'ping -n -c 3 -i 1.2 -W 2 -t 2 10.241.2.10' 'From 169.254.0.1 .*exceeded' +check "TTL 5 : atteint s7-b — quatre routeurs : gateway hv1, VRF hv1, VRF hv2, netns hv2" vm_ssh vp-s7 10.241.1.10 'ping -n -c 1 -W 2 -t 5 10.241.2.10' +check "hv1 : vrf-s7 n'importe pas 10.241.2.20/32 de vp-s7b (RT 64600:2701)" sh -c "[ -z \"\$(ip -4 route show vrf vrf-s7 10.241.2.20)\" ]" +check "s7-a ne joint pas s7-x, autre VPC, même plage" vm_fails vp-s7 10.241.1.10 'ping -c 3 -W 2 10.241.2.20' +NODE +on hv2 <<'NODE' +BGPD=$(pidof bgpd) +check "hv2 : suppression de sn-s7x refusée tant que s7-x existe (409)" test "$(api_code DELETE subnets/sn-s7x)" = 409 +check "hv2 : suppression de s7-x" vm_delete s7-x +check "hv2 : vrf-s7b ne porte plus le /32 de s7-x" test -z "$(ip -4 route show vrf vrf-s7b 10.241.2.20/32)" +check "hv2 : suppression de sn-s7x" api_delete subnets/sn-s7x +check "hv2 : sn-s7x supprimé" wait_state subnets/sn-s7x deleted +check "hv2 : suppression de vp-s7b" api_delete vpcs/vp-s7b +check "hv2 : vp-s7b supprimé" wait_state vpcs/vp-s7b deleted +check "hv2 : plus aucune interface de vp-s7b" sh -c "! ip -o link show | grep -qE '(vrf|brl3|vxl3)-s7b|l3-s7b-o'" +check "hv2 : plus rien de vrf-s7b dans FRR, en mémoire ni dans frr.conf" sh -c "! vtysh -c 'show running-config' | grep -q 'vrf-s7b' && ! grep -q 'vrf-s7b' /etc/frr/frr.conf" +check "hv2 : bgpd n'a pas redémarré pendant le démontage" sh -c "[ \"\$(pidof bgpd)\" = '${BGPD}' ]" +check "hv2 : vp-s7 toujours en service" wait_l3vni 2700 02:02:c0:a8:0e:0c +NODE diff --git a/test/e2e/scenarios/s8-l3vni-migration.sh b/test/e2e/scenarios/s8-l3vni-migration.sh new file mode 100644 index 0000000..f6fe22f --- /dev/null +++ b/test/e2e/scenarios/s8-l3vni-migration.sh @@ -0,0 +1,94 @@ +on hv1 <<'NODE' +two_image || { echo "ÉCHOUÉ: image compatible two (hv1)"; exit 0; } +check "hv1 : VPC vp-s8, l3vni 2800" vpc_create vp-s8 10.242.0.0/16 2800 +check "hv1 : subnet sn-s8s (VNI 2811)" subnet_create sn-s8s vp-s8 2811 10.242.1.1 10.242.1.0/24 +check "hv1 : VM s8-m1 10.242.1.50" vm_create s8-m1 sn-s8s 10.242.1.50 +check "hv1 : s8-m1 répond depuis son netns" netns_ping_wait vp-s8 10.242.1.50 +check "hv1 : /24 et /32 exportés par l'agent" sh -c "ip -4 route show vrf vrf-s8 | grep -q '^10.242.1.0/24 via 169.254.0.2' && ip -4 route show vrf vrf-s8 | grep -q '^10.242.1.50 via 169.254.0.2'" +NODE +on hv2 <<'NODE' +two_image || { echo "ÉCHOUÉ: image compatible two (hv2)"; exit 0; } +check "hv2 : VPC vp-s8, l3vni 2800" vpc_create vp-s8 10.242.0.0/16 2800 +check "hv2 : aucun subnet de vp-s8 au départ" sh -c "! ip link show vxlan-2811 >/dev/null 2>&1" +NODE +on hv3 <<'NODE' +two_image || { echo "ÉCHOUÉ: image compatible two (hv3)"; exit 0; } +KEY=$(vm_key) +check "hv3 : VPC vp-s8, l3vni 2800" vpc_create vp-s8 10.242.0.0/16 2800 +check "hv3 : subnet sn-s8t (VNI 2812), seulement sur hv3" subnet_create sn-s8t vp-s8 2812 10.242.2.1 10.242.2.0/24 +check "hv3 : VM observatrice s8-o 10.242.2.10" vm_create s8-o sn-s8t 10.242.2.10 "${KEY}" +check "s8-o joignable" vm_wait vp-s8 10.242.2.10 +check "hv3 : aucun VXLAN de sn-s8s sur l'observateur" sh -c "! ip link show vxlan-2811 >/dev/null 2>&1" +check "hv3 : /32 de s8-m1 via hv1 seulement" wait_vrf_nexthops vp-s8 10.242.1.50 192.168.14.11 +for i in $(seq 1 24); do vm_ssh vp-s8 10.242.2.10 'ping -c 1 -W 2 10.242.1.50' >/dev/null 2>&1 && break; sleep 5; done +check "s8-o (hv3) joint s8-m1 (hv1)" vm_ssh vp-s8 10.242.2.10 'ping -n -c 3 -W 2 10.242.1.50' +check "1472 octets en -M do" vm_ssh vp-s8 10.242.2.10 'ping -n -M do -s 1472 -c 2 -W 2 10.242.1.50' +NODE +on hv1 <<'NODE' +check "migration simple, 1 — suppression de s8-m1 sur hv1 : son /32 part en premier" vm_delete s8-m1 +check "hv1 : plus de /32 pour 10.242.1.50 dans vrf-s8" test -z "$(ip -4 route show vrf vrf-s8 10.242.1.50/32 | grep 169.254.0.2)" +NODE +on hv3 <<'NODE' +check "hv3 : plus aucun /32 pour 10.242.1.50" wait_vrf_nexthops vp-s8 10.242.1.50 "" +check "hv3 : le /24 de sn-s8s reste annoncé par hv1 (filet)" wait_vrf_nexthops vp-s8 10.242.1.0/24 192.168.14.11 +NODE +on hv2 <<'NODE' +check "migration simple, 2 — sn-s8s créé sur hv2 (même VNI 2811)" subnet_create sn-s8s vp-s8 2811 10.242.1.1 10.242.1.0/24 +check "migration simple, 3 — VM s8-m2 10.242.1.50 sur hv2" vm_create s8-m2 sn-s8s 10.242.1.50 +check "hv2 : s8-m2 répond depuis son netns" netns_ping_wait vp-s8 10.242.1.50 +NODE +on hv3 <<'NODE' +start=${SECONDS} +check "hv3 : /32 de 10.242.1.50 via hv2 seulement" wait_vrf_nexthops vp-s8 10.242.1.50 192.168.14.12 +info "hv3 : /32 de hv2 installé $(( SECONDS - start )) s après le passage en running de s8-m2" +check "hv3 : /24 de sn-s8s en ECMP vers hv1 et hv2" wait_vrf_nexthops vp-s8 10.242.1.0/24 "192.168.14.11 192.168.14.12" +for i in $(seq 1 24); do vm_ssh vp-s8 10.242.2.10 'ping -c 1 -W 2 10.242.1.50' >/dev/null 2>&1 && break; sleep 5; done +check "s8-o joint s8-m2 par son /32" vm_ssh vp-s8 10.242.2.10 'ping -n -c 3 -W 2 10.242.1.50' +info "après migration simple : $(ping_rate vp-s8 10.242.2.10 10.242.1.50 50)/50 réponses" +NODE +on hv1 <<'NODE' +info "orchestrée, 1 — sn-s8s présent sur hv1 (destination), /24 annoncé" +check "orchestrée, 2 — VM s8-m3 10.242.1.50 sur hv1 pendant que s8-m2 tourne sur hv2" vm_create s8-m3 sn-s8s 10.242.1.50 +check "hv1 : s8-m3 répond depuis son netns" netns_ping_wait vp-s8 10.242.1.50 +NODE +on rr1 <<'NODE' +check "rr1 : MAC de gateway de sn-s8s propre à chaque hôte, hv1 (02:03:c0:a8:0e:0b) et hv2 (02:03:c0:a8:0e:0c)" sh -c "r=\$(vtysh -c 'show bgp l2vpn evpn route type macip'); echo \"\$r\" | grep -qi '02:03:c0:a8:0e:0b' && echo \"\$r\" | grep -qi '02:03:c0:a8:0e:0c'" +NODE +on hv1 <<'NODE' +check "hv1 : aucune MAC en double sur la VNI 2811" sh -c "! vtysh -c 'show evpn mac vni 2811 duplicate' | grep -qiE '([0-9a-f]{2}:){5}[0-9a-f]{2}'" +NODE +on hv3 <<'NODE' +for i in $(seq 1 30); do [ "$(bgp_paths vp-s8 10.242.1.50/32)" = 2 ] && break; sleep 2; done +info "orchestrée : chemins BGP pour 10.242.1.50/32 : $(bgp_paths vp-s8 10.242.1.50/32) ; meilleur : $(bgp_best vp-s8 10.242.1.50/32) ; installés : $(vrf_nexthops vp-s8 10.242.1.50)" +check "orchestrée : deux /32 annoncés, hv1 et hv2" wait_vrf_nexthops vp-s8 10.242.1.50 "192.168.14.11 192.168.14.12" +check "deux /32, subnet présent des deux côtés : les 40 sources joignent 10.242.1.50, quel que soit le chemin ECMP" sh -c "[ \"\$1\" = 40/40 ]" _ "$(sources_reach vp-s8 br-s8t 10.242.2 10.242.1.50)" +NODE +on hv2 <<'NODE' +check "orchestrée, 3 — sn-s8s non supprimable sur hv2 tant que s8-m2 existe (409)" test "$(api_code DELETE subnets/sn-s8s)" = 409 +check "orchestrée, 4 — suppression de s8-m2 sur hv2 (source) : son /32 part en premier" vm_delete s8-m2 +check "orchestrée, 5 — suppression de sn-s8s sur hv2" api_delete subnets/sn-s8s +check "sn-s8s supprimé sur hv2" wait_state subnets/sn-s8s deleted +NODE +on hv3 <<'NODE' +check "hv3 : /32 de 10.242.1.50 via hv1 seulement" wait_vrf_nexthops vp-s8 10.242.1.50 192.168.14.11 +check "hv3 : /24 de sn-s8s via hv1 seulement" wait_vrf_nexthops vp-s8 10.242.1.0/24 192.168.14.11 +check "après la séquence orchestrée : s8-o joint s8-m3" vm_ssh vp-s8 10.242.2.10 'ping -n -c 3 -W 2 10.242.1.50' +check "après la séquence orchestrée : les 40 sources joignent s8-m3" sh -c "[ \"\$1\" = 40/40 ]" _ "$(sources_reach vp-s8 br-s8t 10.242.2 10.242.1.50)" +NODE +on hv1 <<'NODE' +check "ex-pire cas — suppression de sn-s8s sur hv1 refusée tant que s8-m3 existe (409)" test "$(api_code DELETE subnets/sn-s8s)" = 409 +check "ex-pire cas — sn-s8s toujours running sur hv1" test "$(api_state subnets/sn-s8s)" = running +check "ex-pire cas — /32 et /24 toujours exportés par hv1" sh -c "ip -4 route show vrf vrf-s8 | grep -q '^10.242.1.50 via 169.254.0.2' && ip -4 route show vrf vrf-s8 | grep -q '^10.242.1.0/24 via 169.254.0.2'" +NODE +on hv1 <<'NODE' +check "watchdog : /32 orphelin posé à la main dans vrf-s8" ip route replace 10.242.1.99/32 via 169.254.0.2 dev l3-s8-o vrf vrf-s8 +check "watchdog : /32 orphelin signalé comme trou noir" wait_watchdog "route 10.242.1.99/32 exported in vrf-s8 without a running owner" +check "watchdog : retrait du /32 orphelin" ip route del 10.242.1.99/32 vrf vrf-s8 +check "watchdog : /32 de s8-m3 retiré à la main" ip route del 10.242.1.50/32 vrf vrf-s8 +check "watchdog : /32 manquant signalé" wait_watchdog "route 10.242.1.50/32 not exported in vrf-s8" +check "watchdog : /32 de s8-m3 rétabli" ip route replace 10.242.1.50/32 via 169.254.0.2 dev l3-s8-o vrf vrf-s8 +check "watchdog : aucune alerte BGP ni L3VNI sur hv1" sh -c "! journalctl -u agent --since '-60s' --no-pager -o cat | grep -F 'watchdog: inconsistency detected' | grep -qE '\"kind\":\"bgp\"|l3vni [0-9]|interface (vrf|brl3|vxl3|l3)-'" +NODE +on hv3 <<'NODE' +check "après les essais du watchdog : s8-o joint s8-m3" vm_ssh vp-s8 10.242.2.10 'ping -n -c 3 -W 2 10.242.1.50' +NODE diff --git a/test/e2e/scenarios/s9-subnets-partages.sh b/test/e2e/scenarios/s9-subnets-partages.sh new file mode 100644 index 0000000..f61776c --- /dev/null +++ b/test/e2e/scenarios/s9-subnets-partages.sh @@ -0,0 +1,45 @@ +for host in hv2 hv3; do +on "${host}" "HOST=${host}" <<'NODE' +two_image || { echo "ÉCHOUÉ: image compatible two (${HOST})"; exit 0; } +KEY=$(vm_key) +case "${HOST}" in hv2) n=1 ;; hv3) n=2 ;; esac +check "${HOST} : VPC vp-s9r, l3vni 2900" vpc_create vp-s9r 10.250.0.0/16 2900 +check "${HOST} : subnet sn-s9r1 (VNI 2911)" subnet_create sn-s9r1 vp-s9r 2911 10.250.1.1 10.250.1.0/24 +check "${HOST} : subnet sn-s9r2 (VNI 2912)" subnet_create sn-s9r2 vp-s9r 2912 10.250.2.1 10.250.2.0/24 +check "${HOST} : VM s9-r1-${n} 10.250.1.1${n}" vm_create "s9-r1-${n}" sn-s9r1 "10.250.1.1${n}" "${KEY}" +check "${HOST} : VM s9-r2-${n} 10.250.2.1${n}" vm_create "s9-r2-${n}" sn-s9r2 "10.250.2.1${n}" "${KEY}" +check "${HOST} : VPC vp-s9n, sans l3vni" vpc_create vp-s9n 10.251.0.0/16 +check "${HOST} : subnet sn-s9n1 (VNI 2921)" subnet_create sn-s9n1 vp-s9n 2921 10.251.1.1 10.251.1.0/24 +check "${HOST} : subnet sn-s9n2 (VNI 2922)" subnet_create sn-s9n2 vp-s9n 2922 10.251.2.1 10.251.2.0/24 +check "${HOST} : VM s9-n1-${n} 10.251.1.1${n}" vm_create "s9-n1-${n}" sn-s9n1 "10.251.1.1${n}" "${KEY}" +check "${HOST} : VM s9-n2-${n} 10.251.2.1${n}" vm_create "s9-n2-${n}" sn-s9n2 "10.251.2.1${n}" "${KEY}" +NODE +done + +for host in hv2 hv3; do +on "${host}" "HOST=${host}" <<'NODE' +case "${HOST}" in hv2) n=1; mac=02:03:c0:a8:0e:0c ;; hv3) n=2; mac=02:03:c0:a8:0e:0d ;; esac +for v in r n; do + vpc="vp-s9${v}" + net="10.25$([ "${v}" = r ] && echo 0 || echo 1)" + for s in 1 2; do + src="${net}.${s}.1${n}" + check "${HOST} : ${src} joignable" vm_wait "${vpc}" "${src}" + check "${HOST} : ${src} joint sa gateway ${net}.${s}.1" vm_ssh "${vpc}" "${src}" "ping -n -c 2 -W 2 ${net}.${s}.1" + check "${HOST} : ${src} voit la MAC de gateway de son hôte (${mac})" vm_grep "${vpc}" "${src}" "ip neigh show ${net}.${s}.1" "lladdr ${mac} " + for d in 1 2; do + for m in 1 2; do + dst="${net}.${d}.1${m}" + [ "${dst}" = "${src}" ] && continue + for i in $(seq 1 12); do vm_ssh "${vpc}" "${src}" "ping -n -c 1 -W 2 ${dst}" >/dev/null 2>&1 && break; sleep 5; done + check "${vpc} : ${src} (${HOST}) joint ${dst} ($([ "${d}" = "${s}" ] && echo 'même subnet' || echo 'autre subnet'), $([ "${m}" = "${n}" ] && echo 'même hôte' || echo 'autre hôte'))" \ + vm_ssh "${vpc}" "${src}" "ping -n -c 3 -W 2 ${dst}" + done + done + done +done +for vni in 2911 2912 2921 2922; do + check "${HOST} : aucune MAC en double sur la VNI ${vni}" sh -c "! vtysh -c 'show evpn mac vni ${vni} duplicate' | grep -qiE '([0-9a-f]{2}:){5}[0-9a-f]{2}'" +done +NODE +done diff --git a/test/e2e/topologies/agent/bgp.yml b/test/e2e/topologies/agent/bgp.yml new file mode 100644 index 0000000..0ee09a4 --- /dev/null +++ b/test/e2e/topologies/agent/bgp.yml @@ -0,0 +1,6 @@ +bgp: + asn: 64600 + route_reflectors: [10.255.255.1] +watchdog: + enabled: true + interval_seconds: 10 diff --git a/test/e2e/topologies/agent/two.yml b/test/e2e/topologies/agent/two.yml index 6334d32..47d7f5e 100644 --- a/test/e2e/topologies/agent/two.yml +++ b/test/e2e/topologies/agent/two.yml @@ -1,2 +1,8 @@ dhcp: backend: two +bgp: + asn: 64600 + route_reflectors: [10.255.255.1] +watchdog: + enabled: true + interval_seconds: 10 diff --git a/test/e2e/topologies/evpn-2hv.yml b/test/e2e/topologies/evpn-2hv.yml index 0176ef1..293da21 100644 --- a/test/e2e/topologies/evpn-2hv.yml +++ b/test/e2e/topologies/evpn-2hv.yml @@ -21,8 +21,9 @@ nodes: loopback: 10.255.255.1/32, frr: frr/rr1.conf } hv1: { role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay], - addresses: { underlay: 192.168.14.11 }, frr: frr/hv1.conf, release: 0.2.0rc003, + addresses: { underlay: 192.168.14.11 }, frr: frr/hv1.conf, release: 0.2.0rc008, agent: agent/two.yml } hv2: { role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay], - addresses: { underlay: 192.168.14.12 }, frr: frr/hv2.conf, release: 0.2.0rc003 } + addresses: { underlay: 192.168.14.12 }, frr: frr/hv2.conf, release: 0.2.0rc008, + agent: agent/bgp.yml } diff --git a/test/e2e/topologies/evpn-3hv.yml b/test/e2e/topologies/evpn-3hv.yml new file mode 100644 index 0000000..7b2893d --- /dev/null +++ b/test/e2e/topologies/evpn-3hv.yml @@ -0,0 +1,33 @@ +name: evpn-3hv + +images: + debian12: + url: https://cloud.debian.org/images/cloud/bookworm/latest/debian-12-generic-amd64.qcow2 + sums: https://cloud.debian.org/images/cloud/bookworm/latest/SHA512SUMS + +segments: + underlay: + switch: sw1 + cidr: 192.168.14.0/24 + mtu: 9000 + +nodes: + sw1: + { role: switch, image: debian12, cpus: 2, memory: 1024, + secondary: { underlay: [169.254.0.1/28] }, frr: frr/sw1.conf } + rr1: + { role: rr, image: debian12, cpus: 1, memory: 1024, segments: [underlay], + addresses: { underlay: 192.168.14.2 }, secondary: { underlay: [169.254.0.3/28] }, + loopback: 10.255.255.1/32, frr: frr/rr1.conf } + hv1: + { role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay], + addresses: { underlay: 192.168.14.11 }, frr: frr/hv1.conf, release: 0.2.0rc008, + agent: agent/two.yml } + hv2: + { role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay], + addresses: { underlay: 192.168.14.12 }, frr: frr/hv2.conf, release: 0.2.0rc008, + agent: agent/bgp.yml } + hv3: + { role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay], + addresses: { underlay: 192.168.14.13 }, frr: frr/hv3.conf, release: 0.2.0rc008, + agent: agent/bgp.yml } diff --git a/test/e2e/topologies/frr/hv1.conf b/test/e2e/topologies/frr/hv1.conf index ecf9e12..fd12d21 100644 --- a/test/e2e/topologies/frr/hv1.conf +++ b/test/e2e/topologies/frr/hv1.conf @@ -2,18 +2,3 @@ frr defaults traditional hostname hv1 log syslog informational ! -router bgp 64600 - bgp router-id 192.168.14.11 - no bgp default ipv4-unicast - neighbor fabric peer-group - neighbor fabric remote-as 64600 - neighbor fabric capability extended-nexthop - neighbor 10.255.255.1 peer-group fabric - ! - address-family l2vpn evpn - neighbor fabric activate - advertise-all-vni - exit-address-family - ! -exit -! diff --git a/test/e2e/topologies/frr/hv2.conf b/test/e2e/topologies/frr/hv2.conf index 5d0e0d9..e6eb488 100644 --- a/test/e2e/topologies/frr/hv2.conf +++ b/test/e2e/topologies/frr/hv2.conf @@ -2,18 +2,3 @@ frr defaults traditional hostname hv2 log syslog informational ! -router bgp 64600 - bgp router-id 192.168.14.12 - no bgp default ipv4-unicast - neighbor fabric peer-group - neighbor fabric remote-as 64600 - neighbor fabric capability extended-nexthop - neighbor 10.255.255.1 peer-group fabric - ! - address-family l2vpn evpn - neighbor fabric activate - advertise-all-vni - exit-address-family - ! -exit -! diff --git a/test/e2e/topologies/frr/hv3.conf b/test/e2e/topologies/frr/hv3.conf new file mode 100644 index 0000000..f79906e --- /dev/null +++ b/test/e2e/topologies/frr/hv3.conf @@ -0,0 +1,4 @@ +frr defaults traditional +hostname hv3 +log syslog informational +!