Compare commits

..

No commits in common. "9e08b69339bdbc6dcc4c04f85f10ce643b0aa463" and "c090607785aec0acb59e6afcc9e827ca541d6fad" have entirely different histories.

52 changed files with 859 additions and 2691 deletions

View file

@ -503,11 +503,10 @@ components:
VMMetadata:
type: object
description: >
cloud-init inputs for this VM. Every field is optional. The served
user-data is user_data when given, empty otherwise: an empty
user_data is the same as no user_data. meta-data, network-config and
vendor-data always come from the agent's built-in templates
(vendor-data creates the syonad account from password and sshkey).
cloud-init inputs for this VM. Every field is optional. Documents not
supplied here fall back to the agent's built-in templates; a document
supplied as an empty string is served empty, which is not the same
thing.
properties:
password:
type: string

View file

@ -80,7 +80,7 @@ l'adresse d'émission :
L'adresse d'émission est la même sur tous les hôtes : une VM qui reçoit la requête ARP d'un autre
hôte associe ``.253`` à la MAC de celui-ci. C'est sans effet — la VM ne parle jamais d'elle-même à
``.253`` et le netns lui parle depuis la gateway. Mesuré en lab (``44-fenetre-arp``) : pendant
``.253`` et le netns lui parle depuis la gateway. Mesuré en lab (``s11-fenetre-arp``) : pendant
cette fenêtre, métadonnées, renouvellement DHCP et connexions depuis le netns passent sans perte.
.. note::

View file

@ -64,7 +64,7 @@ Topologies
----------
Les topologies de two vivent dans ``test/e2e/topologies/`` : ``evpn-2hv.yml`` (deux hyperviseurs)
et ``evpn-3hv.yml`` (trois, celle de la suite). Le format est celui de ``labctl`` :
et ``evpn-3hv.yml`` (trois, pour ``s8`` et ``s9``). Le format est celui de ``labctl`` :
.. literalinclude:: ../../test/e2e/topologies/evpn-2hv.yml
:language: yaml
@ -113,17 +113,7 @@ télécharge la release sur ``git.g3e.fr`` sans réessayer : le script attend d'
réponde, à travers le switch. Les deux fichiers ``agent/`` donnent à l'agent la section ``bgp``
(AS 64600, route reflectors ``10.255.255.1`` et ``10.255.255.2``) et un watchdog toutes les 10 s ;
``agent/two.yml`` met en plus hv1 sur le serveur DHCP intégré (``dhcp.backend: two``),
``agent/dnsmasq.yml`` met explicitement les autres sur dnsmasq (``dhcp.backend: dnsmasq``).
**Segment ``lan`` (mode ``bridge``).** hv1 et hv2 sont aussi reliés à un second segment,
``lan`` (``10.33.0.0/24``, MTU 1500, **sans routeur** : L2 pur, sans passerelle ni NAT),
déclaré après ``underlay`` pour ne changer ni ses adresses ni ses taps. Avant ``deploy.sh``,
``hypervisor.sh`` crée le bridge ``br-lan`` (STP coupé, MTU de l'interface), y rattache
l'interface ``lan`` et y déplace l'adresse que labctl lui a donnée (``10.33.0.11`` sur hv1,
``10.33.0.12`` sur hv2). Les deux fichiers ``agent/`` déclarent ``interfaces: {lan: br-lan}`` :
un subnet créé avec ``mode: bridge`` et ``iface_type: lan`` rattache son veth à ``br-lan``. Les
subnets ``vxlan`` (``iface_type: vms``, clé absente) restent sur ``default_interface`` : le VTEP
ne change pas. Le bridge n'est créé qu'au premier démarrage, comme le reste du provisionnement.
``agent/bgp.yml`` laisse les autres sur dnsmasq.
**Tester l'arbre courant plutôt que la release.** ``test/e2e/build.sh`` compile ``agent``,
``dhcp`` et ``metadata`` pour linux/amd64 dans ``test/e2e/topologies/bin/`` (ignoré par git),
@ -201,285 +191,113 @@ Vérifié le 2026-10-04 sur le serveur de lab, topologie ``evpn-2hv``, release `
déploie l'infrastructure (MikroTik aujourd'hui ; Cisco, Juniper, Arista… demain) : il n'a besoin
que de BGP et d'EVPN, et sa configuration propre au constructeur n'a pas sa place dans le lab.
Suite de tests
--------------
Scénarios
---------
La suite (`#70 <https://git.g3e.fr/syonad/two/issues/70>`_) vit dans ``test/e2e/suite/`` : **un
fichier par fonctionnalité**, rangés en couches de bas en haut. Chaque couche ne s'appuie que sur
les précédentes, et les tests de panne passent en dernier. Elle remplace les scénarios ``s1`` à
``s11``, écrits au fil des tickets : chacune de leurs 251 vérifications est reprise (tableau de
correspondance sur #70).
.. list-table::
:header-rows: 1
:widths: 18 82
* - Couche
- Contenu
* - 00 socle
- lab, prérequis d'environnement, image des VM
* - 10 API
- refus de l'API, machine d'états
* - 20 VM
- DHCP (backend ``two`` et dnsmasq), métadonnées, UEFI, multi-NIC, multi-disque, redémarrage
* - 30 réseau local
- gateway anycast, VXLAN sur un hôte, mode ``bridge``, isolation, filtrage au port
* - 40 EVPN L2
- subnet étendu entre hôtes, isolation, subnets partagés, fenêtre ARP
* - 50 L3VNI
- routage entre subnets, migration, watchdog L3
* - 60 cycle de vie
- redémarrage de l'agent, nettoyage global
* - 70 résilience
- perte d'un route reflector, perte d'un switch
Les tests se lancent **depuis le Mac**, sur un lab démarré (``up``, ``push``, ``./labctl up``) :
Les scénarios se lancent **depuis le Mac**, sur un lab démarré (``up``, ``push``, ``./labctl up``) :
.. code-block:: text
test/e2e/run.sh all # toute la suite, dans l'ordre
test/e2e/run.sh 40 # une couche
test/e2e/run.sh 41 43 # des tests, par numéro ou par nom
test/e2e/run.sh --from 30 # à partir d'un numéro
test/e2e/run.sh --continue all # sans s'arrêter sur une couche en échec
test/e2e/run.sh --connus all # les échecs connus comptent comme des échecs
test/e2e/run.sh --matrice # matrice de couverture, tirée des en-têtes
test/e2e/run.sh s1 # un scénario
test/e2e/run.sh s1 s3 # plusieurs
test/e2e/run.sh all # tous, dans l'ordre
Chaque test affiche une ligne ``RÉUSSI`` ou ``ÉCHOUÉ`` par vérification (un échec porte la
dernière ligne de la commande en cause), des lignes ``INFO`` pour les mesures, puis son bilan. Le
code de sortie vaut 1 si une vérification échoue **ou si aucune n'a été faite**. Avec ``all`` ou
``--from``, une couche en échec arrête la suite à la fin de la couche.
**Tests autonomes.** Avant chaque test, le runner supprime les ressources ``tNN`` laissées par un
passage précédent, puis relève l'état de chaque hôte de l'en-tête ``# hôtes:``. Après le test, il
supprime ses VM, ses subnets puis ses VPC, et vérifie que l'hôte est revenu à l'état relevé
(``assert_clean`` : netns, liens, adresses, routes, règles ebtables et iptables, configuration FRR et
``frr.conf``, fichiers de ``/run/two``, ``dnsmasq.d`` et des volumes, unités ``two-vm-*``,
processus dnsmasq et QEMU). Aucun test ne dépend d'un autre : n'importe lequel se lance seul.
**Plages.** Le test ``NN`` nomme ses ressources ``vp-tNN*``, ``sn-tNN*`` et ``tNN-*``, et utilise
``10.NN.0.0/16`` et les VNI ``NN00`` à ``NN99`` : aucune collision entre tests.
**Échecs connus.** Un contrôle dont l'échec est connu et rattaché à un ticket s'écrit ``known
"#NN" "description" commande…`` au lieu de ``check``. En échec, il sort en ``CONNU`` sans faire
échouer le test (bilan : ``N connu(s)``). Dès qu'il passe, il sort en ``INATTENDU`` et fait
échouer le test : le marqueur est à retirer. Pour un échec **intermittent**, ``known_flaky`` sort
en ``RÉUSSI`` (annoté) quand l'échec ne se reproduit pas, sans rappel automatique : le retrait se
fait en fermant le ticket. Chaque ticket concerné liste ses marqueurs en commentaire.
Matrice de couverture
~~~~~~~~~~~~~~~~~~~~~
Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régénérer quand un test change.
Chacun affiche une ligne ``RÉUSSI`` ou ``ÉCHOUÉ`` par vérification — un échec porte la dernière
ligne de la commande en cause —, des lignes ``INFO`` pour les mesures, puis son bilan. Le code de
sortie vaut 1 si une vérification échoue **ou si aucune n'a été faite**.
.. list-table::
:header-rows: 1
:widths: 22 58 20
* - Test
- Fonctionnalité
- Hôtes
- Tickets
* - ``01-lab``
- socle du lab — underlay, passerelle VRRP, sessions EVPN, base BGP posée par l'agent, backend DHCP, watchdog silencieux
- hv1 hv2 hv3
- #50, #51, #54, #41
* - ``02-prerequis``
- hypothèses d'environnement de la suite — firmware UEFI, unités modèles de l'agent, journalctl, format de ebtables -L, br-lan, priorités VRRP lues dans FRR
- hv1 hv2 hv3
- #70
* - ``03-image``
- hypothèses sur l'image de VM — outils (curl, python3), nom d'interface, effet réel de network-config, forme du compte verrouillé
* - Scénario
- Ce qui doit être vrai
- Hyperviseurs
* - ``s1-dhcp-two``
- backend DHCP ``two``, une VPC et deux subnets : chaque VM reçoit l'adresse de **son**
subnet, démarrée seule ou en même temps qu'une autre ; le bail est tenu par
systemd-networkd ; route par défaut, route vers la VPC et ``/32`` vers les métadonnées
via la gateway calculée (``.254``) ; l'état de chaque serveur DHCP ne connaît que les MAC de
son subnet (#46)
- hv1
- #70
* - ``11-validation``
- validation de l'API — refus synchrones (400, 409, 422) des VPC, subnets et VM, sans trace en base
* - ``s2-gateway``
- gateway (``.254``) et adresse d'émission (``.253``) calculées par l'agent, refusées pour
une VM ; ``interface_ip`` refusé sur un subnet ``vxlan`` (#57) ; route par défaut via la
gateway, ou via ``gateway`` avec ``default_route`` ; route vers la VPC toujours via la
gateway du subnet ; macvlan retiré à la suppression, même résultat après recréation (#31)
- hv1
- #41, #57, #33
* - ``12-etats``
- machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom
* - ``s3-isolation-local``
- deux VPC sur le même hyperviseur ne se joignent pas, en ICMP comme en TCP ; chaque VM
joint sa passerelle (témoin)
- hv1
- #41
* - ``21-dhcp-two``
- DHCP par le serveur intégré (backend two) — bail, server-id, renouvellement, option 121, un serveur par subnet, démarrages simultanés
- hv1
- #46, #57
* - ``22-dhcp-dnsmasq``
- DHCP par dnsmasq (backend dnsmasq) — bail, server-id, renouvellement, option 121, une instance par subnet écoutant sur la gateway anycast
- hv2
- #46, #57
* - ``23-metadonnees``
- serveur de métadonnées et cloud-init — sshkey, password (hash), user_data servi tel quel, documents absents (templates), VM sans compte
- hv1
- #43, #46
* - ``24-uefi``
- démarrage UEFI (OVMF) — firmware et variables par VM, VM démarrée en UEFI, témoin BIOS
- hv1
- UEFI (sans ticket)
* - ``25-multi-nic``
- VM à plusieurs interfaces — une NIC par subnet, adresses posées, route par défaut sur la primaire seule
- hv1
- #33, #62
* - ``26-multi-disque``
- VM à plusieurs disques — virtio (vdX) et SCSI (sdX), tailles et bus vus par la VM, démarrage sur vda
- hv1
- #32
* - ``27-reboot``
- redémarrage d'une VM depuis l'invité — même processus QEMU, même adresse, nouveau bail, user_data non rejoué
- hv1
- #46
* - ``31-gateway``
- gateway d'un subnet vxlan — gateway anycast et adresse d'émission calculées, default_route et gateway explicite, routes DHCP, macvlan gw-, FDB locale, sysctls ARP, règles de confinement, suppression et recréation
- hv1
- #57, #43
* - ``32-vxlan-local``
- routage entre deux subnets vxlan d'une même VPC sur un même hôte, sans et avec l3vni — ICMP, TCP, saut unique par la gateway
- hv1
- #57, #41
* - ``33-bridge``
- subnet en mode bridge rattaché au bridge br-lan de l'hôte — un hôte, puis le même subnet sur deux hôtes (une seule réponse ARP pour interface_ip, métadonnées servies par l'hôte de la VM)
- hv1 hv2
- #70
* - ``34-isolation-locale``
- isolation entre deux VPC sur un même hôte — ni ICMP ni TCP d'une VPC à l'autre
- hv1
- #50
* - ``35-filtrage-port``
- filtrage au port — en sortie vers le fabric (v-<id>-i) : ARP vers la gateway et l'adresse d'émission, DHCP émis depuis ces adresses, MAC anycast confinée dans les deux sens ; entre VM d'un même hôte : faux serveur DHCP et usurpation ARP de la gateway (comportement attendu, non filtré à ce jour)
- hv1
- #57
* - ``41-evpn-l2``
- subnet vxlan étendu entre deux hôtes par EVPN — VTEP local, VTEP distant et inondation appris, MAC des VM en type 2, trafic ICMP et TCP, MTU 1500 de bout en bout
- hv1 hv2
- #50, #51
* - ``42-isolation-evpn``
- isolation entre VPC à travers EVPN — deux VPC sur la même plage, la VM d'une VPC ne joint pas celle de l'autre sur un hôte distant
- hv1 hv2
- #50, #51
* - ``43-subnets-partages``
- subnets vxlan partagés par deux hôtes, deux VM par hôte, dans une VPC avec et une VPC sans l3vni — toutes les paires, gateway anycast vue par chaque VM et absente d'EVPN, aucune MAC en double
- hv2 hv3
- #57, #41
* - ``44-fenetre-arp``
- fenêtre ARP de la gateway anycast entre deux hôtes — relais L2 depuis l'adresse d'émission d'un hôte, gateway de la VM inchangée, métadonnées, renouvellement DHCP et TCP local sans perte pendant la fenêtre
- hv1 hv2
- #57
* - ``51-l3vni``
- routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, démontage d'une VPC routée
- hv1 hv2
- #41
* - ``52-migration``
- migration d'une adresse de VM entre hôtes d'une VPC routée — /32 retiré en premier, /24 en filet puis en ECMP, séquence orchestrée, 40 sources, suppression du subnet refusée tant qu'une VM l'utilise, MAC anycast hors EVPN
- hv1 hv2 hv3
- #41, #57
* - ``53-watchdog-l3``
- watchdog d'une VPC routée — /32 orphelin signalé comme trou noir, /32 manquant signalé, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais
- hv1 hv3
- #41
* - ``61-redemarrage-agent``
- redémarrage de l'agent avec des VM en marche — rien ne disparaît ni n'est recréé, trafic routé sans perte, DHCP et métadonnées servis, base BGP réappliquée à l'identique, ressources toujours gérées
- hv1 hv2
- #41, #46
* - ``62-nettoyage-global``
- nettoyage global en fin de suite — aucun hôte ne garde de ressource : API vide, ni netns, tap, VRF, unité, instance DHCP ou de métadonnées, processus QEMU, règle de port, volume ; FRR réduit à la base BGP
-
- #70
* - ``71-perte-rr``
- perte d'un route reflector — l'autre garde la session EVPN, le VTEP distant reste connu, le trafic L2 entre hôtes passe sans perte mesurable, retour du RR arrêté
- hv1 hv2
- #54
* - ``72-perte-switch``
- perte d'un switch de la passerelle VRRP — bascule vers l'autre en moins de 5 s, sessions EVPN jamais coupées ; au retour, le plus prioritaire redevient maître, seconde bascule mesurée
-
- #54, #69
* - ``s4-evpn``
- adresse VTEP locale sur les VXLAN (#51), VTEP distant appris par EVPN, ping VM ↔ VM
entre hyperviseurs, trame de 1472 octets en ``-M do``, 1473 refusés
- hv1, hv2
* - ``s5-isolation-evpn``
- deux VPC de même plage, VNI différentes, sur deux hyperviseurs : la VM joint celle de sa
VPC sur l'autre hyperviseur (témoin) et pas celle de l'autre VPC — aucune résolution ARP
- hv1, hv2
* - ``s6-rr-loss``
- FRR arrêté sur rr1, puis sur rr2, ping continu entre les VM
de ``s4`` : la session vers le route reflector arrêté tombe, celle vers l'autre reste
établie, le VTEP distant reste connu et **le trafic continue** (au moins 45 réponses sur 50
à 30 s) ; session rétablie au redémarrage, délai mesuré ; au plus 1 % de pertes sur tout le
scénario (#54)
- hv1, hv2, rr1, rr2
* - ``s7-l3vni``
- qualification de `#41 <https://git.g3e.fr/syonad/two/issues/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 anycast de la gateway
absente d'EVPN (aucune route de type 2 sur rr1, absente de la table de hv1), sans doublon
(#57) ; 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 anycast de sa gateway ; aucune MAC en
double et aucune MAC anycast dans EVPN sur les quatre VNI (#57)
- hv2, hv3, rr1
* - ``s10-switch-loss``
- un seul switch maître VRRP de la passerelle (lu par ``show vrrp``, pas supposé) ; interface
``underlay`` du maître coupée pendant un ping continu de hv1 vers la loopback de rr1 :
l'autre switch devient maître, les sessions EVPN de hv1 **ne tombent pas** (compteur
``dropped`` inchangé), le trafic reprend (au moins 45 réponses sur 50 à 20 s), plus long
silence sous 5 s ; interface rétablie : ses sessions eBGP reviennent et il **reste en
attente**, sans reprendre la passerelle (#54)
- hv1, sw1, sw2
* - ``s11-fenetre-arp``
- fenêtre ARP de #57 : sur hv1, entrées ARP du netns retirées, puis une VM de hv1 joint une VM
de hv2 dans l'autre subnet (relais L2 depuis l'adresse d'émission de hv1). La VM de hv2
associe alors ``.253`` à la MAC de hv1 (fenêtre ouverte, vérifiée), mais sa gateway reste
la MAC anycast ; pendant la fenêtre, métadonnées servies, bail DHCP renouvelé auprès de
``.254``, et **aucune** des 80 connexions TCP du netns de hv2 vers sa VM n'est perdue ; MAC
anycast inscrite dans la FDB du bridge du netns
- hv1, hv2
Campagne du 2026-10-17
~~~~~~~~~~~~~~~~~~~~~~
``s6`` réutilise les VM de ``s4`` : le lancer après.
Première campagne de la suite, ``evpn-3hv.yml``, labctl ``0.2.0``, binaires de l'arbre courant
(code de l'agent identique à ``main``). ``run.sh --continue all`` en 76 min, dont environ 15 min
d'arrêts de VM à 300 s et 15 min d'attentes sur des tests en échec. Les hypothèses fausses des
tests ont été corrigées sur le serveur et les tests concernés rejoués. Il reste :
* tout vert, sauf les échecs réels, marqués ``known`` et rattachés à leur ticket : multi-NIC
(#73, #62), noms des disques SCSI (#74), mode ``bridge`` sur plusieurs hôtes (#75), filtrage au
port (#76), socket DHCP (#77), fausse alerte du watchdog (#78) ;
* #69 vérifié : au retour de ``sw1`` (priorité 200), il redevient maître, seconde bascule en
1,2 s, sessions EVPN jamais coupées ;
* une suppression de VM peut durer 300 s quand l'invité ignore l'arrêt ACPI (#79) : ``wait_state``
attend jusqu'à 360 s.
Hypothèses vérifiées en lab, à garder en tête en écrivant un test :
* systemd-networkd **ne réécrit pas** un bail renouvelé à l'identique : un renouvellement se
vérifie par le DHCPACK dans le journal du serveur (``lease_renewed``), pas par le fichier de bail ;
* l'agent n'accepte **qu'un seul disque virtio** (le disque système) ; les autres sont des ``sdX`` ;
* sur Debian 12, ``ebtables -L`` (nft) garde les zéros de tête des MAC ;
* ``interface_ip`` est posée en ``/32`` sur le bridge du netns en mode ``bridge`` ;
* depuis le netns d'un hôte, une VM d'un autre hôte ne répond pas : la réponse repart vers la
gateway de son propre hôte. Une vérification entre hôtes passe par une 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 :
.. code-block:: text
test/e2e/labctl.sh ssh "./labctl ssh hv1 'sudo ip netns exec vp-t41 ssh -i /root/.ssh/lab-vm syonad@10.41.1.10'"
Écrire un test
~~~~~~~~~~~~~~
Un test est un fichier ``test/e2e/suite/NN-nom.sh``, exécuté par ``run.sh`` sur le Mac. Il
commence par un en-tête, puis envoie des blocs aux nœuds par ``on <nœud> [VAR=valeur…] <<'NODE'``.
Chaque bloc est précédé des bibliothèques de ``test/e2e/lib/`` :
* ``core.sh`` : ``check``, ``known``, ``info``, appels à l'API, attente des états ;
* ``vm.sh`` : image Debian compatible two, clé SSH, ``vm_launch`` (plusieurs NIC et disques, UEFI,
``user_data``, mot de passe), SSH, bail, métadonnées ;
* ``net.sh`` : VPC, subnets, MAC anycast, trames brutes, règles ebtables, VRRP ;
* ``evpn.sh`` : VRF, BGP, L3VNI, watchdog ;
* ``fixture.sh`` : nettoyage et ``assert_clean``, appelés par le runner.
.. code-block:: bash
# fonctionnalité: trafic entre deux VM d'un même subnet sur un hôte
# hôtes: hv1
# tickets: #NN
on hv1 <<'NODE'
KEY=$(vm_key)
check "VPC vp-t99" vpc_create vp-t99 10.99.0.0/16
check "subnet sn-t99" subnet_create sn-t99 vp-t99 9901 10.99.1.0/24
check "VM t99-a" vm_launch t99-a --nic sn-t99=10.99.1.10 --sshkey "${KEY}"
check "VM t99-b" vm_launch t99-b --nic sn-t99=10.99.1.11 --sshkey "${KEY}"
check "t99-a joignable" vm_wait vp-t99 10.99.1.10
check "t99-a joint t99-b" vm_ssh vp-t99 10.99.1.10 'ping -c 2 -W 2 10.99.1.11'
check "t99-a ne joint pas 10.98.1.10" vm_fails vp-t99 10.99.1.10 'ping -c 2 -W 2 10.98.1.10'
NODE
Les règles :
* **une vérification par ligne**, avec ``check`` : jamais un ``echo RÉUSSI`` écrit à la main ;
* **toute vérification négative a son témoin** : avant « ne joint pas », une ligne qui prouve que
la cible est vivante et que le chemin du test fonctionne ;
* **``vm_fails`` pour le négatif**, jamais ``!`` devant un ``vm_ssh`` : un SSH en panne doit
échouer, pas passer pour une isolation ;
* **une donnée qui distingue réellement les cas** : two dérive la MAC du rang de l'IP, donc deux
subnets ont les mêmes MAC ; comparer des couples MAC/IP, pas des MAC ;
* **les mesures en ``INFO``**, les attentes en ``check`` : un temps de reconvergence se mesure,
il ne se décrète pas ;
* **l'en-tête ``# hôtes:`` liste exactement les hôtes où le test crée des ressources** : ce sont
ceux que le runner nettoie et compare ;
* **un échec connu se marque** ``known`` (ou ``known_flaky``) avec son ticket, et le ticket liste
le marqueur : jamais un contrôle retiré ou affaibli pour faire passer la suite ;
* variables vers un nœud : ``on hv1 NOM=valeur <<'NODE'`` (valeurs échappées par ``run.sh``) ;
* ``bash test/e2e/run_test.sh`` vérifie le runner, les bibliothèques et la syntaxe de chaque bloc
réellement envoyé : à lancer avant toute session.
Campagnes précédentes
~~~~~~~~~~~~~~~~~~~~~
Résultats obtenus avec les anciens scénarios ``s1`` à ``s11``, conservés pour leurs constats.
Leurs vérifications sont reprises dans la suite.
**Comment c'est fait.** ``test/e2e/run.sh`` exécute chaque scénario sur le Mac ; un
scénario envoie des blocs de shell aux nœuds par ``on <nœud> [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`` ; 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.
Résultats du 2026-10-04 sur le serveur de lab, release ``0.2.0rc003``, hv1 sur le DHCP intégré et
hv2 sur dnsmasq — toute la série en 8 minutes :
@ -584,6 +402,54 @@ redémarrage de FRR. ``s10`` : ``sw2`` coupé, ``sw1`` maître, 14 requêtes per
silence 2,8 s, sessions EVPN de hv1 jamais coupées ; ``sw2`` rétabli reste en attente.
``s9`` sans ``Broken pipe`` cette fois : #57 n'est pas corrigé pour autant.
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 :
.. code-block:: text
test/e2e/labctl.sh ssh "./labctl ssh hv1 'sudo ip netns exec vp-s4 ssh -i /root/.ssh/lab-vm syonad@10.240.1.10'"
Écrire un scénario
~~~~~~~~~~~~~~~~~~
Le lab sert à qualifier des comportements qui ne se voient qu'à plusieurs hyperviseurs — la
campagne L3VNI de `#41 <https://git.g3e.fr/syonad/two/issues/41>`_ en est le prochain exemple. Un
scénario est un fichier ``test/e2e/scenarios/<n>-<nom>.sh``, exécuté par ``run.sh`` sur le
Mac ; il envoie des blocs aux nœuds :
.. code-block:: bash
on hv1 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two"; exit 0; }
KEY=$(vm_key)
check "VPC vp-x" vpc_create vp-x 10.250.0.0/16
check "subnet sn-x" subnet_create sn-x vp-x 2601 10.250.1.1 10.250.1.0/24
check "VM x1" vm_create x1 sn-x 10.250.1.10 "${KEY}"
check "x1 joignable" vm_wait vp-x 10.250.1.10
check "x1 joint sa passerelle" vm_ssh vp-x 10.250.1.10 'ping -c 2 -W 2 10.250.1.1'
check "x1 ne joint pas 10.251.1.10" vm_fails vp-x 10.250.1.10 'ping -c 2 -W 2 10.251.1.10'
info "mesure : $(vtysh -c 'show evpn vni 2601' | grep -c 'flood')"
NODE
Les règles qui ont fait leurs preuves en E5 :
* **une vérification par ligne**, avec ``check`` — jamais un ``echo RÉUSSI`` écrit à la main ;
* **toute vérification négative a son témoin** : avant « ne joint pas », une ligne qui prouve que
la cible est vivante et que le chemin du test fonctionne ;
* **``vm_fails`` pour le négatif**, jamais ``!`` devant un ``vm_ssh`` : un SSH en panne doit
échouer, pas passer pour une isolation ;
* **une donnée qui distingue réellement les cas** : two dérivant la MAC du rang de l'IP, deux
subnets ont les mêmes MAC — comparer des couples MAC/IP, pas des MAC ;
* **les mesures en ``INFO``**, les attentes en ``check`` : un temps de reconvergence se mesure,
il ne se décrète pas ;
* chaque scénario crée ses propres VPC, plages et VNI, distinctes de celles des autres, pour que
``all`` les enchaîne sur le même lab ; un scénario qui dépend d'un autre le vérifie en tête
(``check "prérequis : …"``) ;
* variables vers un nœud : ``on hv1 NOM=valeur <<'NODE'`` (valeurs échappées par
``run.sh``) ;
* ``bash test/e2e/run_test.sh`` vérifie la syntaxe de chaque bloc réellement envoyé — à
lancer avant toute session.
Sécurité
--------
@ -605,5 +471,5 @@ Tests
bash test/e2e/run_test.sh
Sans réseau : vérifie le runner, les fonctions de ``test/e2e/lib/`` et la syntaxe de chaque bloc
réellement envoyé aux nœuds par la suite. Les tests de l'outil sont dans le dépôt ``labctl``.
Sans réseau : vérifie la syntaxe de chaque bloc réellement envoyé aux nœuds par les scénarios et
les fonctions de ``test/e2e/lib/node.sh``. Les tests de l'outil sont dans le dépôt ``labctl``.

View file

@ -1,83 +0,0 @@
set -u
API=http://127.0.0.1:8080
IMAGE_URL=https://cloud.debian.org/images/cloud/bookworm/latest
IMAGE_FILE=debian-12-genericcloud-amd64.qcow2
TWO_IMAGE=/var/tmp/deb-two.qcow2
VM_KEY=/root/.ssh/lab-vm
VOLUMES=/var/lib/two/volumes
check () {
local desc="${1}" out
shift
if out=$("$@" 2>&1); then
echo "RÉUSSI: ${desc}"
else
echo "ÉCHOUÉ: ${desc}${out:+ — $(printf '%s' "${out}" | tail -n 1)}"
fi
}
known () {
local ticket="${1}" desc="${2}" out
shift 2
if out=$("$@" 2>&1); then
echo "INATTENDU: ${desc} (${ticket}) passe, retirer le marqueur known"
else
echo "CONNU: ${desc} (${ticket})${out:+ — $(printf '%s' "${out}" | tail -n 1)}"
fi
}
known_flaky () {
local ticket="${1}" desc="${2}" out
shift 2
if out=$("$@" 2>&1); then
echo "RÉUSSI: ${desc} (${ticket}, intermittent : non reproduit cette fois)"
else
echo "CONNU: ${desc} (${ticket}, intermittent)${out:+ — $(printf '%s' "${out}" | tail -n 1)}"
fi
}
info () { echo "INFO: ${1}"; }
api_post () {
curl -fsS -o /dev/null -X POST -H 'Content-Type: application/json' -d "${2}" "${API}/${1}"
}
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
}
wait_state () {
local path="${1}" want="${2}" i s
for i in $(seq 1 180); do
s=$(api_state "${path}")
[ "${s}" = "${want}" ] && return 0
[ "${want}" = deleted ] && [ -z "${s}" ] && return 0
[ "${s}" = error ] && { echo "${path}: error" >&2; return 1; }
sleep 2
done
echo "${path}: ${s:-absent}, ${want} attendu" >&2
return 1
}
api_post_code () {
curl -s -o /dev/null -w '%{http_code}' -X POST -H 'Content-Type: application/json' -d "${2}" "${API}/${1}"
}
expect_code () {
local want="${1}" got
shift
got=$("$@")
[ "${got}" = "${want}" ] || { echo "code ${got:-absent}, ${want} attendu"; return 1; }
}
api_field () {
curl -fsS "${API}/${1}" | jq -r ".${2} // empty"
}

View file

@ -1,135 +0,0 @@
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
}
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/ $//'
}
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"))"'
}
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
}
watchdog_alerts () {
journalctl -u agent --since "-${1:-300}s" --no-pager -o cat | grep -F 'watchdog: inconsistency detected'
}
watchdog_quiet () {
local out
out=$(watchdog_alerts "${1:-300}" | { if [ -n "${2:-}" ]; then grep -vF -- "${2}"; else cat; fi; }) || return 0
printf '%s\n' "${out}"
return 1
}
watchdog_quiet_about () {
local out
out=$(watchdog_alerts "${1}" | grep -F -- "${2}") || return 0
printf '%s\n' "${out}"
return 1
}
evpn_mac_remote () {
vtysh -c "show evpn mac vni ${1} json" 2>/dev/null |
jq -e --arg m "$(tr 'A-F' 'a-f' <<<"${2}")" --arg v "${3}" '(.macs // {})[$m] | .type == "remote" and .remoteVtep == $v' >/dev/null
}
evpn_mac_json_shape () {
local out
out=$(vtysh -c "show evpn mac vni ${1} json" 2>/dev/null)
jq -e '[(.macs // {})[] | select(.type == "remote")] | length > 0 and all(has("remoteVtep"))' >/dev/null <<<"${out}" && return 0
echo "VNI ${1} : champs d'une MAC distante : $(jq -c '[(.macs // {})[] | select(.type == "remote")][0] // {} | keys' <<<"${out}" 2>/dev/null)"
return 1
}
wait_evpn_mac () {
local i
for i in $(seq 1 30); do
evpn_mac_remote "$@" && return 0
sleep 2
done
echo "VNI ${1} : ${2} non apprise en type 2 via ${3}" >&2
return 1
}
wait_bgp_paths () {
local i n
for i in $(seq 1 15); do
n=$(bgp_paths "${1}" "${2}")
[ "${n}" = "${3}" ] && return 0
sleep 2
done
echo "vrf-${1#vp-} ${2} : ${n:-?} chemin(s) BGP, ${3} attendu(s)" >&2
return 1
}
watchdog_l3_quiet () {
local out
out=$(journalctl -u agent --since "-${1:-60}s" --no-pager -o cat | grep -F 'watchdog: inconsistency detected' | grep -E '"kind":"bgp"|l3vni [0-9]|interface (vrf|brl3|vxl3|l3)-') || return 0
printf '%s\n' "${out}"
return 1
}

View file

@ -1,79 +0,0 @@
STATE_DIR=/var/tmp/e2e
owned () {
grep -E "^(vp-|sn-)?t${T}"
}
api_names () {
curl -fsS "${API}/${1}" | jq -r '.[] | select(.state != "deleted") | .name'
}
delete_owned () {
local kind="${1}" name rc=0
for name in $(api_names "${kind}" | owned); do
api_delete "${kind}/${name}" && wait_state "${kind}/${name}" deleted || { echo "${kind}/${name} : suppression en échec" >&2; rc=1; }
done
return "${rc}"
}
teardown_owned () {
delete_owned vms && delete_owned subnets && delete_owned vpcs || return 1
rm -f "${VOLUMES}/t${T}"-*
local left
left=$(for kind in vms subnets vpcs; do api_names "${kind}" | owned | sed "s|^|${kind}/|"; done | tr '\n' ' ')
[ -z "${left}" ] || { echo "encore présents : ${left}"; return 1; }
}
host_state () {
echo "## netns"; ip netns list | awk '{print $1}' | sort
echo "## liens"; ip -o link show | awk -F': ' '{print $2}' | cut -d@ -f1 | sort
echo "## adresses"; ip -o -4 addr show | awk '{print $2, $4}' | sort
echo "## routes"; ip -4 route show table all | grep -v '^local \|^broadcast ' | sort
echo "## ebtables"; ebtables -t filter -L; ebtables -t nat -L
echo "## iptables"; iptables-save | grep -v '^#' | sed 's/ \[[0-9]*:[0-9]*\]$//'
echo "## frr"; vtysh -c 'show running-config' | grep -v '^Building\|^Current configuration\|^!'
echo "## frr.conf"; sha256sum /etc/frr/frr.conf | cut -d' ' -f1
echo "## fichiers"; find /run/two /etc/dnsmasq.d "${VOLUMES}" -mindepth 1 ! -type d ! -path '/run/two/dhcp/*.sock' 2>/dev/null | sort
echo "## unités"; systemctl list-units --all --plain --no-legend 'two-vm-*' | awk '{print $1}'
echo "## processus"; pgrep -a dnsmasq | cut -d' ' -f2- | sort; echo "qemu: $(pgrep -c qemu-system)"
}
prepare_test () {
mkdir -p "${STATE_DIR}"
if [ -n "$(for kind in vms subnets vpcs; do api_names "${kind}" | owned; done)" ]; then
info "${HOST} : ressources t${T} d'un passage précédent, suppression"
check "${HOST} : nettoyage des ressources t${T} restantes" teardown_owned
fi
host_state > "${STATE_DIR}/t${T}.avant"
}
state_unchanged () {
local i diff
for i in $(seq 1 15); do
diff=$(diff "${STATE_DIR}/t${T}.avant" <(host_state)) && return 0
sleep 2
done
printf '%s\n' "${diff}"
echo "$(grep -c '^[<>]' <<<"${diff}") différence(s), dont : $(grep -m 1 '^[<>]' <<<"${diff}")"
return 1
}
state_section () {
awk -v s="## ${2}" '/^## / {p = ($0 == s); next} p' "${1}"
}
section_unchanged () {
local now d
now=$(mktemp)
host_state > "${now}"
d=$(diff <(state_section "${1}" "${2}") <(state_section "${now}" "${2}"))
rm -f "${now}"
[ -z "${d}" ] && return 0
echo "${2} en cause : $(grep '^[<>]' <<<"${d}" | sed 's/^< /-/; s/^> /+/' | tr '\n' ' ')"
return 1
}
finish_test () {
check "${HOST} : suppression des ressources t${T}" teardown_owned
check "${HOST} : hôte revenu à l'état d'avant le test (assert_clean)" state_unchanged
}

View file

@ -1,207 +0,0 @@
vpc_create () {
local l3vni="${3:+,\"l3vni\":${3}}"
api_state "vpcs/${1}" | grep -qx running && return 0
api_post vpcs "{\"name\":\"${1}\",\"cidr\":\"${2}\"${l3vni}}" && wait_state "vpcs/${1}" running
}
subnet_create () {
local name="${1}" vpc="${2}" vni="${3}" cidr="${4}" extra="${5:-}"
api_state "subnets/${name}" | grep -qx running && return 0
api_post subnets "{\"name\":\"${name}\",\"vpc\":\"${vpc}\",\"mode\":\"vxlan\",\"vxlan_id\":${vni},\"iface_type\":\"vms\",\"cidr\":\"${cidr}\"${extra}}" \
&& wait_state "subnets/${name}" running
}
anycast_mac () {
printf '02:01:00:%02x:%02x:%02x\n' $(( ${1} >> 16 & 255 )) $(( ${1} >> 8 & 255 )) $(( ${1} & 255 ))
}
dhcp_hosts () {
python3 - "/run/two/dhcp/${1}.sock" <<'PY'
import json, socket, sys
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.connect(sys.argv[1])
s.sendall(b'{"verb":"get-state"}\n')
buf = b""
while not buf.endswith(b"\n"):
c = s.recv(65536)
if not c:
break
buf += c
state = json.loads(buf).get("state") or {}
print(" ".join(sorted(h["mac"].lower() + "=" + h["ip"] for h in state.get("hosts") or [])))
PY
}
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
}
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}"
}
subnet_create_bridge () {
local name="${1}" vpc="${2}" cidr="${3}" ip="${4}" type="${5:-lan}"
api_state "subnets/${name}" | grep -qx running && return 0
api_post subnets "{\"name\":\"${name}\",\"vpc\":\"${vpc}\",\"mode\":\"bridge\",\"iface_type\":\"${type}\",\"interface_ip\":\"${ip}\",\"cidr\":\"${cidr}\"}" \
&& wait_state "subnets/${name}" running
}
frames_py () {
cat <<'PY'
import os, socket, struct, sys, time
def macb(s): return bytes(int(x, 16) for x in s.split(':'))
def macs(b): return ':'.join('%02x' % x for x in b)
def ipb(s): return socket.inet_aton(s)
def ifmac(i): return os.environ.get('FRAMES_MAC') or open('/sys/class/net/%s/address' % i).read().strip()
def csum(b):
if len(b) % 2:
b += b'\0'
s = sum(struct.unpack('!%dH' % (len(b) // 2), b))
s = (s >> 16) + (s & 0xffff)
s += s >> 16
return ~s & 0xffff
def eth(dst, src, t, p): return macb(dst) + macb(src) + struct.pack('!H', t) + p
def arp_req(smac, sip, tip):
return eth('ff:ff:ff:ff:ff:ff', smac, 0x0806,
struct.pack('!HHBBH', 1, 0x0800, 6, 4, 1) + macb(smac) + ipb(sip) + bytes(6) + ipb(tip))
def udp_bcast(smac, sip, sport, dport, data):
u = struct.pack('!HHHH', sport, dport, 8 + len(data), 0) + data
h = struct.pack('!BBHHHBBH4s4s', 0x45, 0, 20 + len(u), 0, 0, 64, 17, 0, ipb(sip), ipb('255.255.255.255'))
h = h[:10] + struct.pack('!H', csum(h)) + h[12:]
return eth('ff:ff:ff:ff:ff:ff', smac, 0x0800, h + u)
def garp(smac, ip):
return eth('ff:ff:ff:ff:ff:ff', smac, 0x0806,
struct.pack('!HHBBH', 1, 0x0800, 6, 4, 2) + macb(smac) + ipb(ip) + macb('ff:ff:ff:ff:ff:ff') + ipb(ip))
def marker(smac, text): return eth('ff:ff:ff:ff:ff:ff', smac, 0x88b5, text.encode().ljust(46, b'\0'))
def sock(i):
s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(3))
s.bind((i, 0))
return s
def emit(i, frame, n):
if os.environ.get('FRAMES_DRY'):
print(frame.hex())
return
s = sock(i)
for _ in range(n):
s.send(frame)
time.sleep(0.2)
def frames(s, sec):
s.settimeout(0.2)
end = time.time() + sec
while time.time() < end:
try:
f, addr = s.recvfrom(4096)
except socket.timeout:
continue
if addr[2] != socket.PACKET_OUTGOING:
yield f
def match(kind, a, f):
t = f[12:14]
if kind == 'arp-req':
return t == b'\x08\x06' and f[20:22] == b'\x00\x01' and f[38:42] == ipb(a[0])
if kind == 'udp-from':
return t == b'\x08\x00' and f[23] == 17 and f[26:30] == ipb(a[0]) and struct.unpack('!H', f[34:36])[0] == int(a[1])
if kind == 'marker':
return t == b'\x88\xb5' and a[0].encode() in f[14:]
if kind == 'src-mac':
return macs(f[6:12]) == a[0].lower()
raise SystemExit('kind inconnu : ' + kind)
cmd, a = sys.argv[1], sys.argv[2:]
if cmd == 'arp':
emit(a[0], arp_req(ifmac(a[0]), a[1], a[2]), int(a[3]))
elif cmd == 'dhcp':
emit(a[0], udp_bcast(ifmac(a[0]), a[1], 67, int(a[2]), b'two-e2e-dhcp'.ljust(240, b'\0')), int(a[3]))
elif cmd == 'garp':
emit(a[0], garp(ifmac(a[0]), a[1]), int(a[2]))
elif cmd == 'marker':
emit(a[0], marker(a[1], a[2]), int(a[3]))
elif cmd == 'count':
print(sum(1 for f in frames(sock(a[0]), float(a[1])) if match(a[2], a[3:], f)))
elif cmd == 'arp-who':
s = sock(a[0])
s.send(arp_req(ifmac(a[0]), a[1], a[2]))
seen = {macs(f[22:28]) for f in frames(s, float(a[3]))
if f[12:14] == b'\x08\x06' and f[20:22] == b'\x00\x02' and f[28:32] == ipb(a[2])}
print('\n'.join(sorted(seen)))
else:
raise SystemExit('commande inconnue : ' + cmd)
PY
}
frames () {
frames_py | python3 - "$@"
}
vm_frames () {
local vpc="${1}" ip="${2}"
shift 2
vm_ssh "${vpc}" "${ip}" "echo $(frames_py | base64 | tr -d '\n') | base64 -d > /tmp/frames.py && sudo python3 /tmp/frames.py $*"
}
sniff_start () {
local out="${1}"
shift
frames count "$@" > "${out}" 2>&1 &
sleep 1
}
vm_sniff_start () {
local out="${1}" vpc="${2}" ip="${3}"
shift 3
vm_frames "${vpc}" "${ip}" count "$@" > "${out}" 2>&1 &
sleep 3
}
ebt_mac () {
awk -F: 'BEGIN {OFS = ":"} {for (i = 1; i <= NF; i++) sub(/^0/, "", $i); $1 = $1; print tolower($0)}' <<<"${1}"
}
ebt_rules () {
{ ip netns exec "${1}" ebtables -t nat -L; ip netns exec "${1}" ebtables -t filter -L; } | grep -- "${2}"
}
ebt_confined () {
ebt_rules "${1}" "${2}" | grep -ciE -- "-s ($(ebt_mac "${3}")|${3}) .*DROP"
}
ebt_arp_drop () {
ebt_rules "${1}" "${2}" | grep -i arp | grep -i request | grep -q -- "${3} "
}
ebt_dhcp_drop () {
ebt_rules "${1}" "${2}" | grep -i udp | grep -- "${3} " | grep -q "67:68"
}
vrrp_expected_master () {
printf '%s\n' "$@" | awk -F: '{split($3, o, "."); k = sprintf("%05d%03d%03d%03d%03d", $2, o[1], o[2], o[3], o[4]); if (k > best) {best = k; name = $1}} END {print name}'
}
log_gap () {
LC_ALL=C awk -F'[][]' -v from="${2:-0}" -v to="${3:-0}" '/bytes from/ {if (prev != "" && $2 >= from && (to == 0 || $2 <= to) && $2 - prev > max) max = $2 - prev; prev = $2} END {printf "%d", max * 10 + 0.5}' "${1}"
}

263
test/e2e/lib/node.sh Normal file
View file

@ -0,0 +1,263 @@
set -u
API=http://127.0.0.1:8080
IMAGE_URL=https://cloud.debian.org/images/cloud/bookworm/latest
IMAGE_FILE=debian-12-genericcloud-amd64.qcow2
TWO_IMAGE=/var/tmp/deb-two.qcow2
VM_KEY=/root/.ssh/lab-vm
VOLUMES=/var/lib/two/volumes
check () {
local desc="${1}" out
shift
if out=$("$@" 2>&1); then
echo "RÉUSSI: ${desc}"
else
echo "ÉCHOUÉ: ${desc}${out:+ — $(printf '%s' "${out}" | tail -n 1)}"
fi
}
info () { echo "INFO: ${1}"; }
api_post () {
curl -fsS -o /dev/null -X POST -H 'Content-Type: application/json' -d "${2}" "${API}/${1}"
}
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
}
wait_state () {
local path="${1}" want="${2}" i s
for i in $(seq 1 90); do
s=$(api_state "${path}")
[ "${s}" = "${want}" ] && return 0
[ "${want}" = deleted ] && [ -z "${s}" ] && return 0
[ "${s}" = error ] && { echo "${path}: error" >&2; return 1; }
sleep 2
done
echo "${path}: ${s:-absent}, ${want} attendu" >&2
return 1
}
vpc_create () {
local l3vni="${3:+,\"l3vni\":${3}}"
api_state "vpcs/${1}" | grep -qx running && return 0
api_post vpcs "{\"name\":\"${1}\",\"cidr\":\"${2}\"${l3vni}}" && wait_state "vpcs/${1}" running
}
subnet_create () {
local name="${1}" vpc="${2}" vni="${3}" cidr="${4}" extra="${5:-}"
api_state "subnets/${name}" | grep -qx running && return 0
api_post subnets "{\"name\":\"${name}\",\"vpc\":\"${vpc}\",\"mode\":\"vxlan\",\"vxlan_id\":${vni},\"iface_type\":\"vms\",\"cidr\":\"${cidr}\"${extra}}" \
&& wait_state "subnets/${name}" running
}
anycast_mac () {
printf '02:01:00:%02x:%02x:%02x\n' $(( ${1} >> 16 & 255 )) $(( ${1} >> 8 & 255 )) $(( ${1} & 255 ))
}
two_image () {
[ -f "${TWO_IMAGE}" ] && return 0
local work
work=$(mktemp -d)
curl -fsSL -o "${work}/${IMAGE_FILE}" "${IMAGE_URL}/${IMAGE_FILE}" || return 1
curl -fsSL "${IMAGE_URL}/SHA512SUMS" | grep " ${IMAGE_FILE}\$" > "${work}/sums" || return 1
(cd "${work}" && sha512sum -c sums >/dev/null) || { echo "image: somme SHA-512 incorrecte" >&2; return 1; }
command -v qemu-nbd >/dev/null || DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends qemu-utils >/dev/null
modprobe nbd max_part=8
qemu-nbd -c /dev/nbd0 "${work}/${IMAGE_FILE}" || return 1
for i in $(seq 1 20); do [ -b /dev/nbd0p1 ] && break; sleep 0.5; done
mkdir -p /mnt/two-image
mount /dev/nbd0p1 /mnt/two-image || { qemu-nbd -d /dev/nbd0 >/dev/null; return 1; }
printf '%s\n' 'datasource_list: [ NoCloud ]' 'datasource:' ' NoCloud:' " seedfrom: 'http://169.254.169.254:80/'" ' timeout: 5' ' max_wait: 10' \
> /mnt/two-image/etc/cloud/cloud.cfg.d/99_metadata.cfg
umount /mnt/two-image
qemu-nbd -d /dev/nbd0 >/dev/null
mv "${work}/${IMAGE_FILE}" "${TWO_IMAGE}"
rm -rf "${work}"
}
vm_key () {
[ -f "${VM_KEY}" ] || ssh-keygen -q -t ed25519 -N '' -C lab-vm -f "${VM_KEY}"
cat "${VM_KEY}.pub"
}
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
api_post vms "{\"name\":\"${name}\",\"memory\":1024,\"cpus\":1,\"metadata\":${meta},\"interfaces\":[{\"subnet\":\"${subnet}\",\"ip\":\"${ip}\",\"primary\":true}],\"storage\":[{\"path\":\"${VOLUMES}/${name}.qcow2\",\"dev\":\"vda\"}]}" \
&& wait_state "vms/${name}" running
}
vm_delete () {
api_delete "vms/${1}" && wait_state "vms/${1}" deleted
}
vm_ssh () {
local vpc="${1}" ip="${2}"
shift 2
ip netns exec "${vpc}" ssh -i "${VM_KEY}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
-o LogLevel=ERROR -o ConnectTimeout=3 -o BatchMode=yes -n "syonad@${ip}" "$@"
}
vm_wait () {
local i
for i in $(seq 1 40); do
vm_ssh "${1}" "${2}" true 2>/dev/null && return 0
sleep 5
done
echo "${2}: SSH injoignable" >&2
return 1
}
vm_fails () {
local out
out=$(vm_ssh "${1}" "${2}" "${3} >/dev/null 2>&1; echo rc=\$?") || { echo "SSH vers ${2} en échec"; return 1; }
case "${out}" in
rc=0) echo "la commande a réussi dans ${2}"; return 1 ;;
rc=*) return 0 ;;
*) echo "sortie inattendue : ${out}"; return 1 ;;
esac
}
vm_grep () {
vm_ssh "${1}" "${2}" "${3} 2>&1" | grep -q -- "${4}"
}
has_addr () {
vm_ssh "${1}" "${2}" 'ip -4 -o addr show dev ens3' | grep -q " ${2}/"
}
route_via () {
vm_ssh "${1}" "${2}" "ip -4 route show ${3}" | grep -q "via ${4} "
}
dhcp_hosts () {
python3 - "/run/two/dhcp/${1}.sock" <<'PY'
import json, socket, sys
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.connect(sys.argv[1])
s.sendall(b'{"verb":"get-state"}\n')
buf = b""
while not buf.endswith(b"\n"):
c = s.recv(65536)
if not c:
break
buf += c
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
}

View file

@ -1,175 +0,0 @@
two_image () {
[ -f "${TWO_IMAGE}" ] && return 0
local work
work=$(mktemp -d)
curl -fsSL -o "${work}/${IMAGE_FILE}" "${IMAGE_URL}/${IMAGE_FILE}" || return 1
curl -fsSL "${IMAGE_URL}/SHA512SUMS" | grep " ${IMAGE_FILE}\$" > "${work}/sums" || return 1
(cd "${work}" && sha512sum -c sums >/dev/null) || { echo "image: somme SHA-512 incorrecte" >&2; return 1; }
command -v qemu-nbd >/dev/null || DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends qemu-utils >/dev/null
modprobe nbd max_part=8
qemu-nbd -c /dev/nbd0 "${work}/${IMAGE_FILE}" || return 1
for i in $(seq 1 20); do [ -b /dev/nbd0p1 ] && break; sleep 0.5; done
mkdir -p /mnt/two-image
mount /dev/nbd0p1 /mnt/two-image || { qemu-nbd -d /dev/nbd0 >/dev/null; return 1; }
printf '%s\n' 'datasource_list: [ NoCloud ]' 'datasource:' ' NoCloud:' " seedfrom: 'http://169.254.169.254:80/'" ' timeout: 5' ' max_wait: 10' \
> /mnt/two-image/etc/cloud/cloud.cfg.d/99_metadata.cfg
umount /mnt/two-image
qemu-nbd -d /dev/nbd0 >/dev/null
mv "${work}/${IMAGE_FILE}" "${TWO_IMAGE}"
rm -rf "${work}"
}
vm_key () {
[ -f "${VM_KEY}" ] || ssh-keygen -q -t ed25519 -N '' -C lab-vm -f "${VM_KEY}"
cat "${VM_KEY}.pub"
}
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
api_post vms "{\"name\":\"${name}\",\"memory\":1024,\"cpus\":1,\"metadata\":${meta},\"interfaces\":[{\"subnet\":\"${subnet}\",\"ip\":\"${ip}\",\"primary\":true}],\"storage\":[{\"path\":\"${VOLUMES}/${name}.qcow2\",\"dev\":\"vda\"}]}" \
&& wait_state "vms/${name}" running
}
vm_delete () {
api_delete "vms/${1}" && wait_state "vms/${1}" deleted
}
vm_ssh () {
local vpc="${1}" ip="${2}"
shift 2
ip netns exec "${vpc}" ssh -i "${VM_KEY}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
-o LogLevel=ERROR -o ConnectTimeout=3 -o BatchMode=yes -n "syonad@${ip}" "$@"
}
vm_wait () {
local i
for i in $(seq 1 40); do
vm_ssh "${1}" "${2}" true 2>/dev/null && return 0
sleep 5
done
echo "${2}: SSH injoignable" >&2
return 1
}
vm_fails () {
local out
out=$(vm_ssh "${1}" "${2}" "${3} >/dev/null 2>&1; echo rc=\$?") || { echo "SSH vers ${2} en échec"; return 1; }
case "${out}" in
rc=0) echo "la commande a réussi dans ${2}"; return 1 ;;
rc=*) return 0 ;;
*) echo "sortie inattendue : ${out}"; return 1 ;;
esac
}
vm_grep () {
vm_ssh "${1}" "${2}" "${3} 2>&1" | grep -q -- "${4}"
}
has_addr () {
vm_ssh "${1}" "${2}" 'ip -4 -o addr show dev ens3' | grep -q " ${2}/"
}
route_via () {
vm_ssh "${1}" "${2}" "ip -4 route show ${3}" | grep -q "via ${4} "
}
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
}
vm_body () {
local name="${1}" subnet="${2}" ip="${3}" disk="${4:-${VOLUMES}/${1}.qcow2}" meta="${5:-{\}}" dev="${6:-vda}"
printf '{"name":"%s","memory":1024,"cpus":1,"metadata":%s,"interfaces":[{"subnet":"%s","ip":"%s","primary":true}],"storage":[{"path":"%s","dev":"%s"}]}' \
"${name}" "${meta}" "${subnet}" "${ip}" "${disk}" "${dev}"
}
vm_json () {
local name="${1}" nics='[]' disks='[]' meta='{}' uefi=false primary=true
shift
while [ $# -gt 0 ]; do
case "${1}" in
--nic) nics=$(jq -c --arg s "${2%%=*}" --arg ip "${2#*=}" --argjson p "${primary}" '. + [{subnet: $s, ip: $ip, primary: $p}]' <<<"${nics}"); primary=false; shift 2 ;;
--disk) disks=$(jq -c --arg d "${2%%=*}" --arg p "${2#*=}" '. + [{path: $p, dev: $d}]' <<<"${disks}"); shift 2 ;;
--sshkey) meta=$(jq -c --arg v "${2}" '. + {sshkey: $v}' <<<"${meta}"); shift 2 ;;
--password) meta=$(jq -c --arg v "${2}" '. + {password: $v}' <<<"${meta}"); shift 2 ;;
--user-data) meta=$(jq -c --arg v "${2}" '. + {user_data: $v}' <<<"${meta}"); shift 2 ;;
--uefi) uefi=true; shift ;;
*) echo "vm_json : option inconnue ${1}" >&2; return 1 ;;
esac
done
jq -nc --arg n "${name}" --argjson nics "${nics}" --argjson disks "${disks}" --argjson meta "${meta}" --argjson uefi "${uefi}" \
'{name: $n, memory: 1024, cpus: 1, metadata: $meta, interfaces: $nics, storage: $disks, uefi: $uefi}'
}
vm_launch () {
local name="${1}" body
shift
api_state "vms/${name}" | grep -qx running && return 0
body=$(vm_json "${name}" --disk "vda=${VOLUMES}/${name}.qcow2" "$@") || return 1
mkdir -p "${VOLUMES}"
cp "${TWO_IMAGE}" "${VOLUMES}/${name}.qcow2" || return 1
api_post vms "${body}" && wait_state "vms/${name}" running
}
vm_has_ip () {
vm_ssh "${1}" "${2}" 'ip -4 -o addr show' | grep -q " ${3}/"
}
vm_lease () {
vm_ssh "${1}" "${2}" "sudo cat /run/systemd/netif/leases/\$(cat /sys/class/net/${4:-ens3}/ifindex)" | sed -n "s/^${3}=//p"
}
vm_meta () {
vm_ssh "${1}" "${2}" "curl -fsS http://169.254.169.254/${3}"
}
vm_boot_id () {
vm_ssh "${1}" "${2}" 'cat /proc/sys/kernel/random/boot_id'
}
wait_reboot () {
local i id
for i in $(seq 1 60); do
id=$(vm_boot_id "${1}" "${2}" 2>/dev/null)
[ -n "${id}" ] && [ "${id}" != "${3}" ] && return 0
sleep 5
done
echo "${2} : pas de redémarrage constaté (boot_id ${id:-illisible})" >&2
return 1
}
dhcp_acks () {
journalctl --since "@${1}" --no-pager -o cat -u 'dhcp@*' -u 'dnsmasq@*' | grep -cE "\"type\":5,\"ip\":\"${2}\"|DHCPACK\([^)]*\) ${2} "
}
lease_renewed () {
local t0 i
t0=$(date +%s)
sleep 1
vm_ssh "${1}" "${2}" "sudo networkctl renew ${3:-ens3}" || return 1
for i in $(seq 1 15); do
[ "$(dhcp_acks "${t0}" "${2}")" -gt 0 ] && return 0
sleep 2
done
echo "${2} : aucun DHCPACK du serveur depuis la demande de renouvellement" >&2
return 1
}
ssh_denied () {
local i out
for i in $(seq 1 40); do
out=$(vm_ssh "${1}" "${2}" true 2>&1) && { echo "${2} : SSH accepté"; return 1; }
grep -q 'Permission denied' <<<"${out}" && return 0
sleep 5
done
echo "${2} : ni accepté ni refusé (${out:-aucune réponse})" >&2
return 1
}
vm_neigh_mac () {
vm_ssh "${1}" "${2}" "ip neigh show ${3}" | grep -o 'lladdr [0-9a-f:]*' | cut -d' ' -f2
}

View file

@ -2,26 +2,16 @@
LAB_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
LAB_HOST="${LAB_HOST:-${LAB_DIR}/labctl.sh}"
SUITE_DIR="${SUITE_DIR:-${LAB_DIR}/suite}"
LIBS=(core vm net evpn fixture)
SCENARIO_DIR="${SCENARIO_DIR:-${LAB_DIR}/scenarios}"
SCENARIO_LOG=""
KNOWN_FAIL=0
usage () {
cat >&2 <<USAGE
usage: ${0##*/} [--continue] [--connus] all | --from <NN> | <couche N0>... | <test>...
${0##*/} --matrice
usage: ${0##*/} <scénario>... | all
tests : $(cd "${SUITE_DIR}" && ls -- *.sh 2>/dev/null | sed 's/\.sh$//' | tr '\n' ' ')
scénarios : $(cd "${SCENARIO_DIR}" && ls -- *.sh | sed 's/\.sh$//' | tr '\n' ' ')
Chaque test s'exécute depuis le Mac sur le lab en cours (labctl.sh up, push, ./labctl up).
Une couche se désigne par son numéro (00, 10, …, 70), un test par son numéro ou son nom.
Avant un test, ses ressources t<NN> restantes sont supprimées et l'état de chaque hôte de
l'en-tête « # hôtes: » est relevé ; après, ses ressources sont supprimées et l'hôte doit être
revenu à cet état. Avec all ou --from, une couche en échec arrête la suite (--continue : non).
Un contrôle marqué known (échec connu, rattaché à un ticket) donne CONNU sans compter comme
un échec, ou INATTENDU (compté comme un échec) s'il passe : retirer alors le marqueur. --connus
compte les CONNU comme des échecs. known_flaky (échec intermittent) donne RÉUSSI, annoté, s'il passe.
Chaque scénario s'exécute depuis le Mac sur le lab en cours (labctl.sh up, push, ./labctl up).
Une ligne RÉUSSI ou ÉCHOUÉ par vérification ; code de sortie 1 si une vérification échoue ou
si aucune n'a été faite.
USAGE
@ -29,110 +19,45 @@ USAGE
}
on () {
local node="${1}" assignment lib
local node="${1}" assignment
shift
{
for assignment in "$@"; do
printf 'export %q=%q\n' "${assignment%%=*}" "${assignment#*=}"
done
for lib in "${LIBS[@]}"; do
cat "${LAB_DIR}/lib/${lib}.sh"
done
cat "${LAB_DIR}/lib/node.sh"
cat
} | "${LAB_HOST}" ssh "./labctl ssh ${node} 'sudo bash -s'" 2>&1 | tee -a "${SCENARIO_LOG}"
}
header () {
sed -n "s/^# ${2}: *//p" "${1}" | head -n 1
}
number () {
local name
name=$(basename "${1}")
echo "${name%%-*}"
}
run_scenario () {
local file="${1}" name passed failed known host hosts num
local file="${1}" name passed failed
name="$(basename "${file}" .sh)"
num=$(number "${file}")
hosts=$(header "${file}" hôtes)
SCENARIO_LOG="$(mktemp)"
echo "=== ${name}"
for host in ${hosts}; do
on "${host}" "T=${num}" "HOST=${host}" <<< 'prepare_test'
done
( . "${file}" )
for host in ${hosts}; do
on "${host}" "T=${num}" "HOST=${host}" <<< 'finish_test'
done
passed=$(grep -c '^RÉUSSI: ' "${SCENARIO_LOG}")
failed=$(grep -cE '^(ÉCHOUÉ|INATTENDU): ' "${SCENARIO_LOG}")
known=$(grep -c '^CONNU: ' "${SCENARIO_LOG}")
[[ "${KNOWN_FAIL}" -eq 1 ]] && failed=$(( failed + known ))
failed=$(grep -c '^ÉCHOUÉ: ' "${SCENARIO_LOG}")
rm -f "${SCENARIO_LOG}"
echo "=== ${name} : ${passed} réussi(s), ${failed} échoué(s)$([[ "${known}" -gt 0 ]] && echo ", ${known} connu(s)")"
echo "=== ${name} : ${passed} réussi(s), ${failed} échoué(s)"
[[ "${failed}" -eq 0 && "${passed}" -gt 0 ]]
}
matrix () {
local file
printf '%s\n' '.. list-table::' ' :header-rows: 1' '' \
' * - Test' ' - Fonctionnalité' ' - Hôtes' ' - Tickets'
for file in "${SUITE_DIR}"/*.sh; do
printf ' * - ``%s``\n - %s\n - %s\n - %s\n' "$(basename "${file}" .sh)" \
"$(header "${file}" fonctionnalité)" "$(header "${file}" hôtes)" "$(header "${file}" tickets)"
done
}
select_files () {
local arg file from=""
for arg in "$@"; do
if [[ -n "${from}" ]]; then
[[ "${arg}" =~ ^[0-9]{2}$ ]] || { echo "--from : numéro à deux chiffres attendu" >&2; return 1; }
for file in "${SUITE_DIR}"/*.sh; do
[[ "$(number "${file}")" > "${arg}" || "$(number "${file}")" == "${arg}" ]] && echo "${file}"
done
from=""
elif [[ "${arg}" == --from ]]; then
from=1
elif [[ "${arg}" == all ]]; then
ls "${SUITE_DIR}"/*.sh
elif [[ "${arg}" =~ ^[0-9]0$ ]]; then
ls "${SUITE_DIR}/${arg:0:1}"[0-9]-*.sh 2>/dev/null || { echo "couche vide : ${arg}" >&2; return 1; }
else
file=$(ls "${SUITE_DIR}/${arg}"*.sh 2>/dev/null | head -n 1)
[[ -n "${file}" ]] || { echo "test inconnu : ${arg}" >&2; return 1; }
echo "${file}"
fi
done
[[ -z "${from}" ]] || { echo "--from sans numéro" >&2; return 1; }
}
main () {
local -a files=() args=()
local arg file rc=0 layer="" layer_rc=0 stop=1 sweep=0 out
local -a files=()
local arg file rc=0
[[ $# -gt 0 ]] || usage
for arg in "$@"; do
case "${arg}" in
--continue) stop=0 ;;
--connus) KNOWN_FAIL=1 ;;
--matrice) matrix; return 0 ;;
all|--from) sweep=1; args+=("${arg}") ;;
*) args+=("${arg}") ;;
esac
done
[[ ${#args[@]} -gt 0 ]] || usage
out=$(select_files "${args[@]}") || usage
while IFS= read -r file; do files+=("${file}"); done <<< "${out}"
[[ ${#files[@]} -gt 0 && -n "${files[0]}" ]] || usage
for file in "${files[@]}"; do
[[ "$(number "${file}")" =~ ^[0-9]{2}$ ]] || sweep=0
if [[ "${sweep}" -eq 1 && "${stop}" -eq 1 && -n "${layer}" && "$(number "${file}" | cut -c1)" != "${layer}" && "${layer_rc}" -ne 0 ]]; then
echo "=== couche ${layer}0 en échec : arrêt de la suite (--continue pour poursuivre)"
return 1
if [[ "${arg}" == all ]]; then
files+=("${SCENARIO_DIR}"/*.sh)
continue
fi
[[ "$(number "${file}" | cut -c1)" != "${layer}" ]] && { layer=$(number "${file}" | cut -c1); layer_rc=0; }
run_scenario "${file}" || { rc=1; layer_rc=1; }
file=$(ls "${SCENARIO_DIR}/${arg}"*.sh 2>/dev/null | head -n 1)
[[ -n "${file}" ]] || { echo "scénario inconnu : ${arg}" >&2; usage; }
files+=("${file}")
done
for file in "${files[@]}"; do
run_scenario "${file}" || rc=1
done
return "${rc}"
}

View file

@ -28,7 +28,7 @@ FAKE
}
run () {
env LAB_HOST="${WORK}/lab-host" FAKE_DIR="${WORK}" SUITE_DIR="${SUITE_DIR:-${WORK}/scenarios}" \
env LAB_HOST="${WORK}/lab-host" FAKE_DIR="${WORK}" SCENARIO_DIR="${SCENARIO_DIR:-${WORK}/scenarios}" \
FAKE_OUT="${FAKE_OUT:-}" bash "${DIR}/run.sh" "$@" > "${WORK}/out.log" 2>&1
}
@ -39,7 +39,7 @@ teardown () {
}
node () {
bash -c "$(printf ". '%s'; " "${DIR}"/lib/{core,vm,net,evpn,fixture}.sh)${1}" 2>&1
bash -c ". '${DIR}/lib/node.sh'; ${1}" 2>&1
}
test_on_sends_assignments_library_and_block_to_the_node () {
@ -47,7 +47,7 @@ test_on_sends_assignments_library_and_block_to_the_node () {
printf '%s\n' "on hv2 KEY='ssh-ed25519 AAAA x' NAME=vm <<'NODE'" 'echo "${NAME}"' 'NODE' > "${WORK}/scenarios/t1.sh"
FAKE_OUT='RÉUSSI: un' run t1 || fail "code de sortie $?"
[[ $(cat "${WORK}/calls.log") == "ssh ./labctl ssh hv2 'sudo bash -s'" ]] || fail "appel : $(cat "${WORK}/calls.log")"
grep -q '^check () {' "${WORK}/payload.1" || fail "bibliothèque absente du bloc"
grep -q '^check () {' "${WORK}/payload.1" || fail "node.sh absent du bloc"
[[ $(tail -n 1 "${WORK}/payload.1") == 'echo "${NAME}"' ]] || fail "bloc du scénario absent en fin d'envoi"
[[ $(bash -c "$(grep '^export ' "${WORK}/payload.1"); printf '%s|%s' \"\${KEY}\" \"\${NAME}\"") == "ssh-ed25519 AAAA x|vm" ]] \
|| fail "variables mal transmises : $(grep '^export ' "${WORK}/payload.1")"
@ -88,21 +88,15 @@ test_all_runs_every_scenario_and_fails_if_one_fails () {
}
test_every_shipped_block_is_valid_bash () {
local f dir
for dir in scenarios suite; do
[[ -d "${DIR}/${dir}" ]] || continue
setup "chaque bloc envoyé par ${dir}/ est du bash valide"
sleep () { :; }
export -f sleep
SUITE_DIR="${DIR}/${dir}" FAKE_OUT='RÉUSSI: x' run --continue all
unset -f sleep
for f in "${WORK}"/syntax.*; do
[[ -s "${f}" ]] && fail "${f##*/} : $(cat "${f}")"
done
[[ $(ls "${WORK}" | grep -c '^payload\.') -ge 10 ]] || fail "trop peu de blocs envoyés : $(ls "${WORK}" | grep -c '^payload\.')"
grep -q 'ÉCHOUÉ: syntaxe' "${WORK}/out.log" && fail "bloc invalide"
teardown
local f
setup "chaque bloc envoyé par les scénarios livrés est du bash valide"
SCENARIO_DIR="${DIR}/scenarios" FAKE_OUT='RÉUSSI: x' run all
for f in "${WORK}"/syntax.*; do
[[ -s "${f}" ]] && fail "${f##*/} : $(cat "${f}")"
done
[[ $(ls "${WORK}" | grep -c '^payload\.') -ge 10 ]] || fail "trop peu de blocs envoyés : $(ls "${WORK}" | grep -c '^payload\.')"
grep -q 'ÉCHOUÉ: syntaxe' "${WORK}/out.log" && fail "bloc invalide"
teardown
}
test_check_reports_success_and_failure_with_reason () {
@ -234,393 +228,6 @@ test_watchdog_reported_matches_only_watchdog_alerts () {
teardown
}
suite_file () {
printf '%s\n' "# fonctionnalité: ${3:-f}" "# hôtes: ${2}" "# tickets: #70" "on hv1 <<'NODE'" 'true' 'NODE' > "${WORK}/scenarios/${1}.sh"
}
test_selection_by_layer_test_and_from () {
setup "sélection : couche, test, --from, inconnu"
suite_file 01-a ""; suite_file 11-b ""; suite_file 12-c ""; suite_file 21-d ""
FAKE_OUT='RÉUSSI: x' run 10
[[ $(grep '^=== [0-9a-z-]*$' "${WORK}/out.log" | tr '\n' ' ') == "=== 11-b === 12-c " ]] || fail "couche 10 : $(grep '^=== ' "${WORK}/out.log" | tr '\n' ' ')"
FAKE_OUT='RÉUSSI: x' run 12
[[ $(grep '^=== [0-9a-z-]*$' "${WORK}/out.log" | tr '\n' ' ') == "=== 12-c " ]] || fail "test 12"
FAKE_OUT='RÉUSSI: x' run --from 12
[[ $(grep '^=== [0-9a-z-]*$' "${WORK}/out.log" | tr '\n' ' ') == "=== 12-c === 21-d " ]] || fail "--from 12 : $(grep '^=== ' "${WORK}/out.log" | tr '\n' ' ')"
run 30; [[ $? -eq 2 ]] || fail "couche vide acceptée"
run --from; [[ $? -eq 2 ]] || fail "--from sans numéro accepté"
teardown
}
test_failed_layer_stops_the_sweep_unless_continue () {
setup "all : une couche en échec arrête la suite, sauf --continue"
suite_file 01-a ""; suite_file 02-b ""; suite_file 11-c ""
FAKE_OUT='ÉCHOUÉ: x' run all; [[ $? -eq 1 ]] || fail "code"
[[ $(grep -c '^=== 0[12]-[ab] :' "${WORK}/out.log") -eq 2 ]] || fail "la couche 00 n'a pas été jouée en entier"
grep -q '^=== 11-c' "${WORK}/out.log" && fail "couche 10 jouée après l'échec de la couche 00"
grep -q 'couche 00 en échec' "${WORK}/out.log" || fail "arrêt non annoncé"
FAKE_OUT='ÉCHOUÉ: x' run --continue all
grep -q '^=== 11-c :' "${WORK}/out.log" || fail "--continue : couche 10 non jouée"
FAKE_OUT='ÉCHOUÉ: x' run 01 11
grep -q '^=== 11-c :' "${WORK}/out.log" || fail "tests nommés : pas d'arrêt attendu"
teardown
}
test_fixtures_run_on_each_header_host () {
setup "fixtures : préparation et fin sur chaque hôte de l'en-tête, avec T et HOST"
suite_file 41-x "hv1 hv2"
FAKE_OUT='RÉUSSI: x' run 41
[[ $(tr '\n' '|' < "${WORK}/calls.log") == "ssh ./labctl ssh hv1 'sudo bash -s'|ssh ./labctl ssh hv2 'sudo bash -s'|ssh ./labctl ssh hv1 'sudo bash -s'|ssh ./labctl ssh hv1 'sudo bash -s'|ssh ./labctl ssh hv2 'sudo bash -s'|" ]] \
|| fail "appels : $(tr '\n' '|' < "${WORK}/calls.log")"
[[ $(tail -n 1 "${WORK}/payload.1") == prepare_test && $(tail -n 1 "${WORK}/payload.5") == finish_test ]] || fail "fixture absente"
grep -q "^export T=41$" "${WORK}/payload.1" && grep -q "^export HOST=hv2$" "${WORK}/payload.5" || fail "T ou HOST non transmis"
teardown
setup "fixtures : aucune sans en-tête hôtes"
printf '%s\n' "on hv1 <<'NODE'" 'true' 'NODE' > "${WORK}/scenarios/s1.sh"
FAKE_OUT='RÉUSSI: x' run s1
[[ $(wc -l < "${WORK}/calls.log") -eq 1 ]] || fail "fixture envoyée à un scénario sans en-tête"
teardown
}
test_matrix_lists_every_test_from_its_header () {
setup "--matrice : une ligne par test, tirée des en-têtes"
suite_file 41-x "hv1 hv2" "trafic EVPN"
run --matrice
grep -q '^ \* - ``41-x``$' "${WORK}/out.log" && grep -q '^ - trafic EVPN$' "${WORK}/out.log" && grep -q '^ - hv1 hv2$' "${WORK}/out.log" \
|| fail "matrice : $(cat "${WORK}/out.log")"
[[ -s "${WORK}/calls.log" ]] && fail "un nœud a été appelé"
teardown
}
test_owned_keeps_only_the_resources_of_the_test () {
setup "owned : vp-tNN, sn-tNN, tNN- seulement"
[[ $(node 'printf "%s\n" vp-t41a sn-t41b t41-vm vp-t42a t4-x vp-s4 sn-s41 | T=41 owned | tr "\n" " "') == "vp-t41a sn-t41b t41-vm " ]] \
|| fail "$(node 'printf "%s\n" vp-t41a sn-t41b t41-vm vp-t42a t4-x vp-s4 sn-s41 | T=41 owned | tr "\n" " "')"
teardown
}
test_teardown_deletes_vms_then_subnets_then_vpcs () {
setup "teardown_owned : VM, puis subnets, puis VPC, et rien d'autre"
local stub='api_names () { case $1 in vms) [ -f /tmp/.t70.$$ ] || echo t41-a; echo t42-z ;; subnets) echo sn-t41a ;; vpcs) echo vp-t41a ;; esac; }; api_delete () { echo "DEL $1"; [ "$1" = vms/t41-a ] && touch /tmp/.t70.$$; :; }; wait_state () { :; }; rm () { :; }; '
local out
out=$(node "T=41; ${stub}teardown_owned; command rm -f /tmp/.t70.\$\$")
[[ $(grep '^DEL' <<< "${out}" | tr '\n' ' ') == "DEL vms/t41-a DEL subnets/sn-t41a DEL vpcs/vp-t41a " ]] || fail "ordre : ${out}"
grep -q 'encore présents : subnets/sn-t41a vpcs/vp-t41a' <<< "${out}" || fail "restes non signalés : ${out}"
teardown
}
test_state_unchanged_reports_the_difference () {
setup "state_unchanged : même état accepté, différence signalée"
local dir out
dir=$(mktemp -d)
printf '%s\n' '## liens' lo underlay > "${dir}/t41.avant"
[[ $(node "T=41; STATE_DIR='${dir}'; host_state () { printf '%s\n' '## liens' lo underlay; }; state_unchanged && echo OUI") == OUI ]] || fail "état identique refusé"
out=$(node "T=41; STATE_DIR='${dir}'; sleep () { :; }; host_state () { printf '%s\n' '## liens' br-t41a lo underlay; }; state_unchanged || echo NON")
[[ $(tail -n 1 <<< "${out}") == NON ]] || fail "différence acceptée"
grep -q '^1 différence(s), dont : > br-t41a$' <<< "${out}" || fail "résumé : ${out}"
rm -rf "${dir}"
teardown
}
test_api_post_code_and_expect_code () {
setup "api_post_code / expect_code : code HTTP d'un POST, comparaison et message"
[[ $(node 'curl () { echo "$*"; }; api_post_code subnets "{\"a\":1}"') == '-s -o /dev/null -w %{http_code} -X POST -H Content-Type: application/json -d {"a":1} http://127.0.0.1:8080/subnets' ]] \
|| fail "appel : $(node 'curl () { echo "$*"; }; api_post_code subnets "{\"a\":1}"')"
[[ $(node 'expect_code 422 echo 422 && echo OUI') == OUI ]] || fail "code attendu refusé"
[[ $(node 'expect_code 422 echo 202 || echo NON') == $'code 202, 422 attendu\nNON' ]] || fail "écart : $(node 'expect_code 422 echo 202 || echo NON')"
[[ $(node 'expect_code 422 true || echo NON') == $'code absent, 422 attendu\nNON' ]] || fail "code vide accepté"
teardown
}
test_api_field_reads_one_field_or_nothing () {
setup "api_field : un champ du GET, vide s'il manque"
[[ $(node 'curl () { echo "{\"interface_ip\":\"10.11.1.254\"}"; }; api_field subnets/sn-t11a interface_ip') == 10.11.1.254 ]] || fail "champ présent"
[[ -z $(node 'curl () { echo "{\"interface_ip\":\"10.11.1.254\"}"; }; api_field subnets/sn-t11a relay_ip') ]] || fail "champ absent non vide"
teardown
}
test_vm_body_builds_the_create_request () {
setup "vm_body : requête de création, disque par défaut, métadonnées et dev"
[[ $(node 'vm_body t11-a sn-t11a 10.11.1.10') == '{"name":"t11-a","memory":1024,"cpus":1,"metadata":{},"interfaces":[{"subnet":"sn-t11a","ip":"10.11.1.10","primary":true}],"storage":[{"path":"/var/lib/two/volumes/t11-a.qcow2","dev":"vda"}]}' ]] \
|| fail "défaut : $(node 'vm_body t11-a sn-t11a 10.11.1.10')"
[[ $(node 'vm_body t11-b sn-t11a 10.11.1.11 /x.qcow2 "{\"user_data\":\"YQ==\"}" sdb | jq -c "[.metadata.user_data, .storage[0].path, .storage[0].dev]"') == '["YQ==","/x.qcow2","sdb"]' ]] \
|| fail "options : $(node 'vm_body t11-b sn-t11a 10.11.1.11 /x.qcow2 "{\"user_data\":\"YQ==\"}" sdb')"
teardown
}
test_vm_json_builds_nics_disks_metadata_and_uefi () {
setup "vm_json : NIC (la première primaire), disques, métadonnées, uefi"
local out
out=$(node 'vm_json t25-m --disk vda=/v/a.qcow2 --nic sn-a=10.0.1.10 --nic sn-b=10.0.2.10 --disk sda=/v/b.qcow2 --sshkey "ssh-ed25519 AAAA x" --password "\$6\$s\$h" --user-data "I2Nsb3Vk" --uefi')
[[ "${out}" == '{"name":"t25-m","memory":1024,"cpus":1,"metadata":{"sshkey":"ssh-ed25519 AAAA x","password":"$6$s$h","user_data":"I2Nsb3Vk"},"interfaces":[{"subnet":"sn-a","ip":"10.0.1.10","primary":true},{"subnet":"sn-b","ip":"10.0.2.10","primary":false}],"storage":[{"path":"/v/a.qcow2","dev":"vda"},{"path":"/v/b.qcow2","dev":"sda"}],"uefi":true}' ]] \
|| fail "complet : ${out}"
out=$(node 'vm_json t21-a --nic sn-a=10.0.1.10')
[[ "${out}" == '{"name":"t21-a","memory":1024,"cpus":1,"metadata":{},"interfaces":[{"subnet":"sn-a","ip":"10.0.1.10","primary":true}],"storage":[],"uefi":false}' ]] || fail "minimal : ${out}"
[[ $(node 'vm_json t || echo NON' 2>&1) == '{"name":"t","memory":1024,"cpus":1,"metadata":{},"interfaces":[],"storage":[],"uefi":false}' ]] || fail "vide"
[[ $(node 'vm_json t --inconnue x || echo NON') == *NON ]] || fail "option inconnue acceptée"
teardown
}
test_vm_launch_copies_the_system_disk_first_and_waits () {
setup "vm_launch : disque système vda copié en premier, POST, attente de running"
local out
out=$(node 'VOLUMES=/v; TWO_IMAGE=/img; api_state () { echo; }; mkdir () { :; }; cp () { echo "CP $*"; }; api_post () { echo "POST $1 $(jq -c "[.storage[].dev, .interfaces[0].ip]" <<<"$2")"; }; wait_state () { echo "WAIT $*"; }; vm_launch t26-d --nic sn=10.0.0.10 --disk sda=/v/s.qcow2')
[[ "${out}" == $'CP /img /v/t26-d.qcow2\nPOST vms ["vda","sda","10.0.0.10"]\nWAIT vms/t26-d running' ]] || fail "${out}"
[[ $(node 'api_state () { echo running; }; cp () { echo CP; }; api_post () { echo POST; }; vm_launch t --nic s=1.2.3.4 && echo OK') == OK ]] || fail "VM en running relancée"
[[ $(node 'api_state () { echo; }; cp () { echo CP; }; vm_launch t --bad x || echo NON') == *NON ]] || fail "option invalide : disque copié ou POST envoyé"
teardown
}
test_vm_lease_reads_one_field_of_the_interface_lease () {
setup "vm_lease : champ du bail de l'interface demandée"
local stub='vm_ssh () { echo "$3" >&2; printf "%s\n" "ADDRESS=10.0.1.10" "SERVER_ADDRESS=10.0.1.254"; }; '
[[ $(node "${stub}vm_lease vp 10.0.1.10 SERVER_ADDRESS 2>/dev/null") == 10.0.1.254 ]] || fail "server-id"
[[ $(node "${stub}vm_lease vp 10.0.1.10 SERVER_ADDRESS ens4 2>&1 >/dev/null") == *'/sys/class/net/ens4/ifindex'* ]] || fail "interface ignorée"
[[ $(node "${stub}vm_lease vp 10.0.1.10 SERVER 2>/dev/null") == "" ]] || fail "préfixe de champ accepté"
teardown
}
test_vm_has_ip_matches_the_exact_address () {
setup "vm_has_ip : adresse exacte, sur n'importe quelle interface"
local stub='vm_ssh () { echo "3: ens4 inet 10.25.2.10/24 brd 10.25.2.255 scope global ens4"; }; '
[[ $(node "${stub}vm_has_ip vp 10.25.1.10 10.25.2.10 && echo OUI") == OUI ]] || fail "adresse présente refusée"
[[ $(node "${stub}vm_has_ip vp 10.25.1.10 10.25.2.1 || echo NON") == NON ]] || fail "préfixe accepté"
teardown
}
test_wait_reboot_needs_a_new_boot_id () {
setup "wait_reboot : boot_id différent et lisible exigé"
[[ $(node 'sleep () { :; }; vm_boot_id () { echo b2; }; wait_reboot vp ip b1 && echo OUI') == OUI ]] || fail "redémarrage non vu"
[[ $(node 'sleep () { :; }; vm_boot_id () { echo b1; }; wait_reboot vp ip b1 2>&1 || echo NON') == *NON ]] || fail "même boot_id accepté"
[[ $(node 'sleep () { :; }; vm_boot_id () { return 255; }; wait_reboot vp ip b1 2>&1 || echo NON') == *NON ]] || fail "VM injoignable prise pour redémarrée"
teardown
}
test_lease_renewed_requires_a_server_ack () {
setup "lease_renewed : renouvellement demandé, DHCPACK du serveur pour cette adresse"
local f
f=$(mktemp)
[[ $(node "sleep () { :; }; dhcp_acks () { echo 1; }; vm_ssh () { echo \"\$3\" >> '${f}'; }; lease_renewed vp ip && echo OUI") == OUI ]] || fail "renouvellement non vu"
grep -qx 'sudo networkctl renew ens3' "${f}" || fail "renouvellement non demandé : $(cat "${f}")"
[[ $(node "sleep () { :; }; dhcp_acks () { echo 0; }; vm_ssh () { :; }; lease_renewed vp ip 2>&1 || echo NON") == *NON ]] || fail "aucun ACK accepté"
rm -f "${f}"
teardown
}
test_dhcp_acks_counts_both_backends_for_the_ip_only () {
setup "dhcp_acks : ACK du serveur intégré et de dnsmasq, pour cette adresse seulement"
local log='{"msg":"dhcp reply sent","type":5,"ip":"10.21.1.10","target":{}}
{"msg":"dhcp reply sent","type":2,"ip":"10.21.1.10","target":{}}
{"msg":"dhcp reply sent","type":5,"ip":"10.21.1.100","target":{}}
dnsmasq-dhcp[1]: DHCPACK(gw-t22a) 10.21.1.10 00:22:33:00:00:0a
dnsmasq-dhcp[1]: DHCPACK(gw-t22a) 10.21.1.101 00:22:33:00:00:0b'
[[ $(node "journalctl () { printf '%s\n' '${log}'; }; dhcp_acks 0 10.21.1.10") == 2 ]] || fail "$(node "journalctl () { printf '%s\n' '${log}'; }; dhcp_acks 0 10.21.1.10")"
teardown
}
test_ssh_denied_needs_a_permission_denied () {
setup "ssh_denied : refus d'authentification exigé, pas une VM injoignable"
[[ $(node 'sleep () { :; }; vm_ssh () { echo "syonad@10.0.0.1: Permission denied (publickey)." >&2; return 255; }; ssh_denied vp ip && echo OUI') == OUI ]] || fail "refus non reconnu"
[[ $(node 'sleep () { :; }; vm_ssh () { echo "connect to host 10.0.0.1 port 22: Connection timed out" >&2; return 255; }; ssh_denied vp ip 2>&1 || echo NON') == *NON ]] || fail "injoignable pris pour un refus"
[[ $(node 'sleep () { :; }; vm_ssh () { return 0; }; ssh_denied vp ip || echo NON') == *NON ]] || fail "SSH accepté pris pour un refus"
teardown
}
test_subnet_create_bridge_sends_mode_iface_type_and_interface_ip () {
setup "subnet_create_bridge : mode bridge, iface_type lan par défaut, interface_ip fournie"
local stub='api_state () { echo; }; wait_state () { :; }; api_post () { echo "$1 $2"; }; '
[[ $(node "${stub}subnet_create_bridge sn-t33a vp-t33 10.33.0.0/24 10.33.0.1") == 'subnets {"name":"sn-t33a","vpc":"vp-t33","mode":"bridge","iface_type":"lan","interface_ip":"10.33.0.1","cidr":"10.33.0.0/24"}' ]] \
|| fail "défaut : $(node "${stub}subnet_create_bridge sn-t33a vp-t33 10.33.0.0/24 10.33.0.1")"
[[ $(node "${stub}subnet_create_bridge sn-x vp-x 10.1.0.0/24 10.1.0.1 vms") == *'"iface_type":"vms"'* ]] || fail "iface_type explicite ignoré"
[[ $(node 'api_state () { echo running; }; api_post () { echo POST; }; subnet_create_bridge sn-x vp-x 10.1.0.0/24 10.1.0.1 && echo OK') == OK ]] || fail "subnet existant recréé"
teardown
}
test_ebt_confined_reads_both_mac_forms () {
setup "ebt_confined : MAC avec ou sans zéros de tête (ebtables legacy et nft)"
local stub='ebt_rules () { printf "%s\\n" "-s 02:01:00:00:0c:27 -o v-x-i -j DROP" "-s 2:1:0:0:c:27 -i v-x-i -j DROP" "-s 02:01:00:00:0c:28 -o v-x-i -j DROP"; }; '
[[ $(node "${stub}ebt_confined ns v-x-i 02:01:00:00:0C:27") == 2 ]] || fail "$(node "${stub}ebt_confined ns v-x-i 02:01:00:00:0C:27")"
teardown
}
test_ebt_mac_drops_leading_zeros_like_ebtables () {
setup "ebt_mac : octets sans zéro de tête, en minuscules, comme ebtables -L"
[[ $(node 'ebt_mac 02:01:00:00:0C:1d') == 2:1:0:0:c:1d ]] || fail "$(node 'ebt_mac 02:01:00:00:0C:1d')"
[[ $(node 'ebt_mac aa:10:00:ff:01:00') == aa:10:0:ff:1:0 ]] || fail "$(node 'ebt_mac aa:10:00:ff:01:00')"
teardown
}
test_frames_builds_arp_dhcp_and_marker_frames () {
setup "frames : requête ARP, DHCP en broadcast (somme IP juste) et trame marquée"
local arp dhcp mark
arp=$(node 'FRAMES_DRY=1 FRAMES_MAC=02:00:00:00:00:0a frames arp ens3 10.35.1.10 10.35.1.254 1')
dhcp=$(node 'FRAMES_DRY=1 FRAMES_MAC=02:00:00:00:00:0a frames dhcp ens3 10.35.1.254 68 1')
mark=$(node 'FRAMES_DRY=1 frames marker v-x-e 02:01:00:00:0d:ad t35-x 1')
garp=$(node 'FRAMES_DRY=1 FRAMES_MAC=02:00:00:00:00:0a frames garp ens3 10.35.1.254 1')
python3 - "${arp}" "${dhcp}" "${mark}" "${garp}" <<'PY' || fail "trames : ${arp} / ${dhcp} / ${mark} / ${garp}"
import socket, struct, sys
arp, dhcp, mark, garp = (bytes.fromhex(x) for x in sys.argv[1:])
assert garp[:6] == b'\xff' * 6 and garp[6:12] == bytes.fromhex('02000000000a'), 'garp mac'
assert garp[12:14] == b'\x08\x06' and garp[20:22] == b'\x00\x02', 'garp type/op'
assert garp[22:28] == bytes.fromhex('02000000000a') and garp[28:32] == socket.inet_aton('10.35.1.254'), 'garp émetteur'
assert garp[38:42] == socket.inet_aton('10.35.1.254'), 'garp cible'
assert arp[:6] == b'\xff' * 6 and arp[6:12] == bytes.fromhex('02000000000a'), 'arp mac'
assert arp[12:14] == b'\x08\x06' and arp[20:22] == b'\x00\x01', 'arp type/op'
assert arp[28:32] == socket.inet_aton('10.35.1.10') and arp[38:42] == socket.inet_aton('10.35.1.254'), 'arp ip'
ip = dhcp[14:34]
s = sum(struct.unpack('!10H', ip)); s = (s >> 16) + (s & 0xffff); s += s >> 16
assert s & 0xffff == 0xffff, 'somme IP'
assert dhcp[12:14] == b'\x08\x00' and dhcp[23] == 17 and dhcp[26:30] == socket.inet_aton('10.35.1.254'), 'dhcp ip'
assert struct.unpack('!HH', dhcp[34:38]) == (67, 68), 'dhcp ports'
assert mark[6:12] == bytes.fromhex('020100000dad'), 'marker mac'
assert mark[12:14] == b'\x88\xb5' and b't35-x' in mark[14:] and len(mark) == 60, 'marker'
PY
teardown
}
test_vm_frames_ships_the_script_and_its_arguments () {
setup "vm_frames : le script complet, décodé dans la VM, et ses arguments"
local cmd
cmd=$(node 'vm_ssh () { echo "$1|$2|$3"; }; vm_frames vp-t35 10.35.1.10 arp ens3 10.35.1.10 10.35.1.254 5')
[[ "${cmd}" == "vp-t35|10.35.1.10|echo "*" | base64 -d > /tmp/frames.py && sudo python3 /tmp/frames.py arp ens3 10.35.1.10 10.35.1.254 5" ]] || fail "commande : ${cmd:0:80}…"
local b64=${cmd#*echo }
b64=${b64%% |*}
[[ "$(printf '%s' "${b64}" | base64 -d)" == "$(node 'frames_py')" ]] || fail "script altéré en transit"
teardown
}
test_evpn_mac_remote_requires_type_and_vtep () {
setup "evpn_mac_remote : MAC distante, bon VTEP, casse ignorée"
local json='{"macs":{"00:22:33:00:00:0b":{"type":"remote","remoteVtep":"192.168.14.12"},"00:22:33:00:00:0a":{"type":"local","intf":"tap1"}}}'
local stub="vtysh () { [ \"\$*\" = '-c show evpn mac vni 4101 json' ] && echo '${json}'; }; "
[[ $(node "${stub}evpn_mac_remote 4101 00:22:33:00:00:0B 192.168.14.12 && echo OUI") == OUI ]] || fail "MAC distante refusée"
[[ $(node "${stub}evpn_mac_remote 4101 00:22:33:00:00:0b 192.168.14.11 || echo NON") == NON ]] || fail "mauvais VTEP accepté"
[[ $(node "${stub}evpn_mac_remote 4101 00:22:33:00:00:0a 192.168.14.12 || echo NON") == NON ]] || fail "MAC locale acceptée"
[[ $(node "${stub}evpn_mac_remote 4101 00:22:33:00:00:0c 192.168.14.12 || echo NON") == NON ]] || fail "MAC absente acceptée"
[[ $(node "${stub}evpn_mac_remote 4102 00:22:33:00:00:0b 192.168.14.12 || echo NON") == NON ]] || fail "mauvaise VNI acceptée"
teardown
}
test_vm_neigh_mac_reads_the_resolved_mac () {
setup "vm_neigh_mac : MAC résolue, rien si incomplète"
[[ $(node 'vm_ssh () { echo "10.41.1.11 dev ens3 lladdr 00:22:33:00:00:0b REACHABLE"; }; vm_neigh_mac v 10.41.1.10 10.41.1.11') == 00:22:33:00:00:0b ]] || fail "MAC non lue"
[[ -z $(node 'vm_ssh () { echo "10.41.1.11 dev ens3 INCOMPLETE"; }; vm_neigh_mac v 10.41.1.10 10.41.1.11') ]] || fail "entrée incomplète lue comme une MAC"
teardown
}
test_watchdog_l3_quiet_ignores_route_alerts_only () {
setup "watchdog_l3_quiet : alertes BGP, L3VNI et interfaces L3 refusées, alertes de route ignorées"
local route='{"msg":"watchdog: inconsistency detected","kind":"vpc","name":"vp-t53","problem":"route 10.53.1.99/32 exported in vrf-t53 without a running owner"}'
local bgp='{"msg":"watchdog: inconsistency detected","kind":"bgp","name":"10.255.255.1","problem":"session down"}'
local vni='{"msg":"watchdog: inconsistency detected","kind":"vpc","name":"vp-t53","problem":"l3vni 5300 is not Up"}'
local link='{"msg":"watchdog: inconsistency detected","kind":"vpc","name":"vp-t53","problem":"interface brl3-t53 missing"}'
local other='{"msg":"command failed","kind":"bgp"}'
[[ $(node "journalctl () { echo '${route}'; echo '${other}'; }; watchdog_l3_quiet && echo OUI") == OUI ]] || fail "alerte de route ou message hors watchdog pris pour une alerte L3"
local a
for a in "${bgp}" "${vni}" "${link}"; do
[[ $(node "journalctl () { echo '${a}'; }; watchdog_l3_quiet || echo NON" | tail -n 1) == NON ]] || fail "alerte acceptée : ${a}"
done
[[ $(node "journalctl () { echo \"\$*\" >&2; }; watchdog_l3_quiet 90 2>&1") == "-u agent --since -90s --no-pager -o cat" ]] || fail "fenêtre : $(node "journalctl () { echo \"\$*\" >&2; }; watchdog_l3_quiet 90 2>&1")"
teardown
}
test_vrrp_expected_master_takes_the_highest_priority_then_address () {
setup "vrrp_expected_master : plus haute priorité, puis plus haute adresse"
[[ $(node 'vrrp_expected_master sw1:200:192.168.14.2 sw2:190:192.168.14.3') == sw1 ]] || fail "200 contre 190"
[[ $(node 'vrrp_expected_master sw1:190:192.168.14.2 sw2:200:192.168.14.3') == sw2 ]] || fail "190 contre 200"
[[ $(node 'vrrp_expected_master sw1:100:192.168.14.2 sw2:100:192.168.14.3') == sw2 ]] || fail "égalité : adresse la plus haute"
[[ $(node 'vrrp_expected_master sw1:100:192.168.14.20 sw2:100:192.168.14.3') == sw1 ]] || fail "égalité : comparaison numérique des octets"
[[ $(node 'vrrp_expected_master sw1:99:192.168.14.2 sw2:100:192.168.14.3') == sw2 ]] || fail "99 contre 100"
teardown
}
test_log_gap_measures_the_longest_silence_in_a_window () {
setup "log_gap : plus long silence, en dixièmes, dans une fenêtre"
local log
log=$(mktemp)
printf '%s\n' '[100.0] 64 bytes from x: icmp_seq=1' '[100.2] 64 bytes from x: icmp_seq=2' '[103.0] 64 bytes from x: icmp_seq=3' \
'[103.2] 64 bytes from x: icmp_seq=4' '[110.0] 64 bytes from x: icmp_seq=5' '[110.2] 64 bytes from x: icmp_seq=6' 'no answer yet for icmp_seq=7' > "${log}"
[[ $(node "log_gap '${log}'") == 68 ]] || fail "toute la trace : $(node "log_gap '${log}'")"
[[ $(node "log_gap '${log}' 0 105") == 28 ]] || fail "avant 105 : $(node "log_gap '${log}' 0 105")"
[[ $(node "log_gap '${log}' 105 0") == 68 ]] || fail "silence à cheval sur 105 : $(node "log_gap '${log}' 105 0")"
[[ $(node "log_gap '${log}' 110.1 0") == 2 ]] || fail "après 110.1 : $(node "log_gap '${log}' 110.1 0")"
rm -f "${log}"
teardown
}
test_ebt_matchers_read_the_ebtables_listing () {
setup "ebt_confined / ebt_arp_drop / ebt_dhcp_drop : lecture de ebtables -L"
local stub='ebt_rules () { printf "%s\n" "-s 2:1:0:0:c:27 -i v-x-i -j DROP" "-s 2:1:0:0:c:27 -o v-x-i -j DROP" "-p ARP -o v-x-i --arp-op Request --arp-ip-dst 10.2.1.254 -j DROP" "-p IPv4 -o v-x-i --ip-src 10.2.1.254 --ip-proto udp --ip-sport 67:68 --ip-dport 67:68 -j DROP" | grep -- "$2"; }; '
[[ $(node "${stub}ebt_confined ns v-x-i 02:01:00:00:0c:27") == 2 ]] || fail "confinement : $(node "${stub}ebt_confined ns v-x-i 02:01:00:00:0c:27")"
[[ $(node "${stub}ebt_confined ns v-x-i 02:01:00:00:0c:28") == 0 ]] || fail "autre MAC comptée"
[[ $(node "${stub}ebt_arp_drop ns v-x-i 10.2.1.254 && echo OUI") == OUI ]] || fail "ARP non lu"
[[ $(node "${stub}ebt_arp_drop ns v-x-i 10.2.1.25 || echo NON") == NON ]] || fail "10.2.1.25 pris pour 10.2.1.254"
[[ $(node "${stub}ebt_dhcp_drop ns v-x-i 10.2.1.254 && echo OUI") == OUI ]] || fail "DHCP non lu"
[[ $(node "${stub}ebt_dhcp_drop ns v-y-i 10.2.1.254 || echo NON") == NON ]] || fail "autre interface acceptée"
[[ $(node 'ebt_rules () { echo "-p IPv4 -o v-z-i --ip-src 10.2.1.254 --ip-proto udp --ip-dport 53 -j DROP"; }; ebt_dhcp_drop ns v-z-i 10.2.1.254 || echo NON') == NON ]] || fail "règle UDP hors DHCP prise pour un blocage DHCP"
teardown
}
test_wait_bgp_paths_waits_for_the_expected_count () {
setup "wait_bgp_paths : nombre de chemins attendu, erreur explicite sinon"
[[ $(node 'bgp_paths () { echo 0; }; sleep () { :; }; wait_bgp_paths vp-t53 10.53.1.50/32 0 && echo OUI') == OUI ]] || fail "0 attendu refusé"
local out
out=$(node 'bgp_paths () { echo 1; }; sleep () { :; }; wait_bgp_paths vp-t53 10.53.1.50/32 0 || echo NON')
[[ $(tail -n 1 <<< "${out}") == NON ]] || fail "1 chemin accepté pour 0"
grep -q 'vrf-t53 10.53.1.50/32 : 1 chemin(s) BGP, 0 attendu(s)' <<< "${out}" || fail "message : ${out}"
teardown
}
test_section_unchanged_names_the_changed_entries () {
setup "section_unchanged : une section comparée, entrées en cause nommées"
local dir out
dir=$(mktemp -d)
printf '%s\n' '## liens' lo '## fichiers' /run/two/a /run/two/b '## unités' u1 > "${dir}/avant"
[[ $(node "state_section '${dir}/avant' fichiers | tr '\n' ' '") == "/run/two/a /run/two/b " ]] || fail "section : $(node "state_section '${dir}/avant' fichiers")"
[[ $(node "host_state () { printf '%s\n' '## liens' lo br-x '## fichiers' /run/two/a /run/two/b '## unités' u1; }; section_unchanged '${dir}/avant' fichiers && echo OUI") == OUI ]] || fail "autre section prise en compte"
out=$(node "host_state () { printf '%s\n' '## liens' lo '## fichiers' /run/two/a /run/two/c '## unités' u1; }; section_unchanged '${dir}/avant' fichiers || echo NON")
[[ $(tail -n 1 <<< "${out}") == NON ]] || fail "différence acceptée"
grep -q '^fichiers en cause : -/run/two/b +/run/two/c $' <<< "${out}" || fail "message : ${out}"
rm -rf "${dir}"
teardown
}
test_evpn_mac_json_shape_requires_remote_vtep () {
setup "evpn_mac_json_shape : MAC distante avec remoteVtep, champs listés sinon"
local ok='{"numMacs":2,"macs":{"00:22:33:00:00:0a":{"type":"local","intf":"tap1"},"00:22:33:00:00:0b":{"type":"remote","remoteVtep":"192.168.14.12"}}}'
local ko='{"macs":{"00:22:33:00:00:0b":{"type":"remote","vtep":"192.168.14.12"}}}'
[[ $(node "vtysh () { echo '${ok}'; }; evpn_mac_json_shape 4101 && echo OUI") == OUI ]] || fail "forme attendue refusée"
[[ $(node "vtysh () { echo '${ko}'; }; evpn_mac_json_shape 4101 || echo NON") == *'["type","vtep"]'*NON ]] || fail "champs non listés : $(node "vtysh () { echo '${ko}'; }; evpn_mac_json_shape 4101 || echo NON")"
[[ $(node "vtysh () { echo '{\"macs\":{}}'; }; evpn_mac_json_shape 4101 || echo NON") == *NON ]] || fail "aucune MAC distante acceptée"
teardown
}
test_known_reports_known_failures_and_unexpected_passes () {
setup "known : CONNU en échec, INATTENDU s'il passe, avec le ticket"
[[ $(node 'known "#76" "a" sh -c "echo raison; exit 1"') == "CONNU: a (#76) — raison" ]] || fail "échec : $(node 'known "#76" "a" sh -c "echo raison; exit 1"')"
[[ $(node 'known "#76" "b" true') == "INATTENDU: b (#76) passe, retirer le marqueur known" ]] || fail "réussite : $(node 'known "#76" "b" true')"
teardown
}
test_known_flaky_never_fails_when_it_passes () {
setup "known_flaky : CONNU en échec, RÉUSSI annoté s'il passe"
[[ $(node 'known_flaky "#74" "a" false') == "CONNU: a (#74, intermittent)" ]] || fail "échec : $(node 'known_flaky "#74" "a" false')"
[[ $(node 'known_flaky "#74" "b" true') == "RÉUSSI: b (#74, intermittent : non reproduit cette fois)" ]] || fail "réussite : $(node 'known_flaky "#74" "b" true')"
teardown
}
test_runner_counts_known_apart_unless_connus () {
setup "runner : CONNU hors échecs, INATTENDU en échec, --connus compte les CONNU"
printf '%s\n' "on hv1 <<'NODE'" 'true' 'NODE' > "${WORK}/scenarios/k.sh"
FAKE_OUT='RÉUSSI: a\nCONNU: b (#1)' run k; [[ $? -eq 0 ]] || fail "un CONNU fait échouer le test"
grep -q '=== k : 1 réussi(s), 0 échoué(s), 1 connu(s)' "${WORK}/out.log" || fail "bilan : $(tail -n 1 "${WORK}/out.log")"
FAKE_OUT='RÉUSSI: a\nCONNU: b (#1)' run --connus k; [[ $? -eq 1 ]] || fail "--connus : CONNU non compté"
FAKE_OUT='RÉUSSI: a\nINATTENDU: b (#1) passe' run k; [[ $? -eq 1 ]] || fail "INATTENDU non compté comme un échec"
FAKE_OUT='RÉUSSI: a' run k
grep -q '=== k : 1 réussi(s), 0 échoué(s)$' "${WORK}/out.log" || fail "bilan sans connu : $(tail -n 1 "${WORK}/out.log")"
teardown
}
for T in $(declare -F | awk '{print $3}' | grep '^test_'); do
"${T}"
done

View file

@ -0,0 +1,34 @@
on hv1 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two"; exit 0; }
KEY=$(vm_key)
check "VPC vp-s1" vpc_create vp-s1 10.210.0.0/16
check "subnet sn-s1a" subnet_create sn-s1a vp-s1 2101 10.210.1.0/24
check "subnet sn-s1b" subnet_create sn-s1b vp-s1 2102 10.210.2.0/24
check "backend two : socket de contrôle de sn-s1a" test -S /run/two/dhcp/vp-s1_br-s1a.sock
check "backend two : socket de contrôle de sn-s1b" test -S /run/two/dhcp/vp-s1_br-s1b.sock
check "VM s1-a1, démarrée seule" vm_create s1-a1 sn-s1a 10.210.1.10 "${KEY}"
check "VM s1-a1 joignable" vm_wait vp-s1 10.210.1.10
check "VM s1-b1, démarrée seule" vm_create s1-b1 sn-s1b 10.210.2.10 "${KEY}"
check "VM s1-b1 joignable" vm_wait vp-s1 10.210.2.10
vm_create s1-a2 sn-s1a 10.210.1.11 "${KEY}" > /tmp/s1-a2.log 2>&1 & A=$!
vm_create s1-b2 sn-s1b 10.210.2.11 "${KEY}" > /tmp/s1-b2.log 2>&1 & B=$!
wait "${A}"; RA=$?
wait "${B}"; RB=$?
check "VM s1-a2, démarrée en même temps que s1-b2" test "${RA}" -eq 0
check "VM s1-b2, démarrée en même temps que s1-a2" test "${RB}" -eq 0
for vm in 10.210.1.10:10.210.1.254 10.210.1.11:10.210.1.254 10.210.2.10:10.210.2.254 10.210.2.11:10.210.2.254; do
ip=${vm%%:*}; gw=${vm#*:}
check "${ip} joignable" vm_wait vp-s1 "${ip}"
check "${ip} : adresse de son propre subnet" has_addr vp-s1 "${ip}"
check "${ip} : bail DHCP tenu par systemd-networkd" vm_ssh vp-s1 "${ip}" 'ls /run/systemd/netif/leases/ | grep -q .'
check "${ip} : route par défaut via ${gw}" route_via vp-s1 "${ip}" default "${gw}"
check "${ip} : route vers la VPC via ${gw}" route_via vp-s1 "${ip}" 10.210.0.0/16 "${gw}"
check "${ip} : route /32 vers les métadonnées via ${gw}" route_via vp-s1 "${ip}" 169.254.169.254 "${gw}"
done
vm_host () { echo "$(vm_ssh vp-s1 "${1}" 'cat /sys/class/net/ens3/address')=${1}"; }
A_HOSTS=$(printf '%s\n' "$(vm_host 10.210.1.10)" "$(vm_host 10.210.1.11)" | sort | tr '\n' ' ' | sed 's/ $//')
B_HOSTS=$(printf '%s\n' "$(vm_host 10.210.2.10)" "$(vm_host 10.210.2.11)" | sort | tr '\n' ' ' | sed 's/ $//')
info "sn-s1a : ${A_HOSTS} ; sn-s1b : ${B_HOSTS}"
check "probe sn-s1a : uniquement les couples MAC/IP de sn-s1a" test "$(dhcp_hosts vp-s1_br-s1a)" = "${A_HOSTS}"
check "probe sn-s1b : uniquement les couples MAC/IP de sn-s1b" test "$(dhcp_hosts vp-s1_br-s1b)" = "${B_HOSTS}"
NODE

View file

@ -1,52 +1,30 @@
# fonctionnalité: perte d'un switch de la passerelle VRRP — bascule vers l'autre en moins de 5 s, sessions EVPN jamais coupées ; au retour, le plus prioritaire redevient maître, seconde bascule mesurée
# hôtes:
# tickets: #54, #69
. "${LAB_DIR}/lib/net.sh"
vrrp_state () {
on "${1}" <<'NODE' | sed -n 's/^VRRP: //p'
echo "VRRP: $(vtysh -c 'show vrrp' | awk '/Status \(v4\)/ {print $3}')"
NODE
}
vrrp_priority () {
on "${1}" <<'NODE' | sed -n 's/^PRIO: //p'
p=$(vtysh -c 'show running-config' | awk '$1 == "vrrp" && $3 == "priority" {print $4; exit}')
echo "PRIO: ${p:-100}"
NODE
}
hv1_now () {
on hv1 <<'NODE' | sed -n 's/^NOW: //p'
echo "NOW: $(date +%s.%N)"
NODE
}
on hv1 <<'NODE'
for rr in 10.255.255.1 10.255.255.2; do
check "prérequis : session EVPN de hv1 vers ${rr} établie" sh -c "vtysh -c 'show bgp neighbors ${rr}' | grep -q 'BGP state = Established'"
vtysh -c "show bgp neighbors ${rr}" | grep -o 'dropped [0-9]*' > "/tmp/t72.${rr}"
vtysh -c "show bgp neighbors ${rr}" | grep -o 'dropped [0-9]*' > "/tmp/s10.${rr}"
done
check "prérequis : hv1 joint la loopback de rr1 par la passerelle" ping -c 2 -W 2 10.255.255.1
rm -f /tmp/t72.log
nohup ping -D -i 0.2 10.255.255.1 > /tmp/t72.log 2>&1 &
rm -f /tmp/s10.log
nohup ping -D -i 0.2 10.255.255.1 > /tmp/s10.log 2>&1 &
sleep 5
NODE
SW1=$(vrrp_state sw1)
SW2=$(vrrp_state sw2)
P1=$(vrrp_priority sw1)
P2=$(vrrp_priority sw2)
if [[ "${SW1}" == Master ]]; then
MASTER=sw1 BACKUP=sw2
else
MASTER=sw2 BACKUP=sw1
fi
on hv1 "SW1=${SW1}" "SW2=${SW2}" "P1=${P1}" "P2=${P2}" "MASTER=${MASTER}" <<'NODE'
info "état VRRP : sw1 ${SW1} (priorité ${P1}), sw2 ${SW2} (priorité ${P2})"
check "priorités VRRP lues sur sw1 et sw2" sh -c "[ -n \"\$1\" ] && [ -n \"\$2\" ]" _ "${P1}" "${P2}"
on hv1 "SW1=${SW1}" "SW2=${SW2}" "MASTER=${MASTER}" <<'NODE'
info "état VRRP : sw1 ${SW1}, sw2 ${SW2}"
check "un seul maître VRRP pour la passerelle, l'autre en attente" sh -c "[ \"\$1 \$2\" = 'Master Backup' ] || [ \"\$1 \$2\" = 'Backup Master' ]" _ "${SW1}" "${SW2}"
info "panne simulée sur ${MASTER} : interface underlay coupée"
NODE
@ -59,14 +37,13 @@ sleep 20
on hv1 "MASTER=${MASTER}" "BACKUP_STATE=$(vrrp_state "${BACKUP}")" "BACKUP=${BACKUP}" <<'NODE'
check "${MASTER} coupé : ${BACKUP} est devenu maître" test "${BACKUP_STATE}" = Master
for rr in 10.255.255.1 10.255.255.2; do
check "${MASTER} coupé : session EVPN vers ${rr} toujours établie, sans coupure" sh -c "vtysh -c 'show bgp neighbors ${rr}' | grep -q 'BGP state = Established' && [ \"\$(vtysh -c 'show bgp neighbors ${rr}' | grep -o 'dropped [0-9]*')\" = \"\$(cat /tmp/t72.${rr})\" ]"
check "${MASTER} coupé : session EVPN vers ${rr} toujours établie, sans coupure" sh -c "vtysh -c 'show bgp neighbors ${rr}' | grep -q 'BGP state = Established' && [ \"\$(vtysh -c 'show bgp neighbors ${rr}' | grep -o 'dropped [0-9]*')\" = \"\$(cat /tmp/s10.${rr})\" ]"
done
n=$(LC_ALL=C awk -F'[][]' -v now="$(date +%s)" '/bytes from/ && $2 > now - 10' /tmp/t72.log | wc -l)
n=$(LC_ALL=C awk -F'[][]' -v now="$(date +%s)" '/bytes from/ && $2 > now - 10' /tmp/s10.log | wc -l)
info "${MASTER} coupé depuis 20 s : ${n} réponses de rr1 dans les 10 dernières secondes (50 si tout passe)"
check "${MASTER} coupé : le trafic vers rr1 passe par ${BACKUP} (au moins 45 réponses sur 50)" test "${n}" -ge 45
NODE
T_UP=$(hv1_now)
on "${MASTER}" "NODE_NAME=${MASTER}" <<'NODE'
check "${NODE_NAME} : rétablissement de l'interface underlay" ip link set dev underlay up
for i in $(seq 1 30); do
@ -79,31 +56,18 @@ done
NODE
sleep 10
if [[ "${MASTER}" == sw1 ]]; then CUT_PRIO=${P1}; else CUT_PRIO=${P2}; fi
EXPECTED=$(vrrp_expected_master "sw1:${P1}:192.168.14.2" "sw2:${P2}:192.168.14.3")
if [[ "${EXPECTED}" == sw1 ]]; then OTHER=sw2; else OTHER=sw1; fi
on hv1 "MASTER=${MASTER}" "CUT_PRIO=${CUT_PRIO}" "EXPECTED=${EXPECTED}" "OTHER=${OTHER}" "T_UP=${T_UP}" \
"EXPECTED_STATE=$(vrrp_state "${EXPECTED}")" "OTHER_STATE=$(vrrp_state "${OTHER}")" <<'NODE'
info "${MASTER} rétabli (priorité ${CUT_PRIO}) : maître attendu ${EXPECTED}, le plus prioritaire"
check "${MASTER} rétabli : ${EXPECTED}, le plus prioritaire, est maître" test "${EXPECTED_STATE}" = Master
check "${MASTER} rétabli : ${OTHER} en attente" test "${OTHER_STATE}" = Backup
on hv1 "MASTER=${MASTER}" "MASTER_STATE=$(vrrp_state "${MASTER}")" "BACKUP=${BACKUP}" "BACKUP_STATE=$(vrrp_state "${BACKUP}")" <<'NODE'
check "${MASTER} rétabli : il reste en attente, sans reprendre la passerelle" test "${MASTER_STATE}" = Backup
check "${MASTER} rétabli : ${BACKUP} reste maître" test "${BACKUP_STATE}" = Master
pkill -f 'ping -D -i 0.2 10.255.255.1' || true
sleep 1
for rr in 10.255.255.1 10.255.255.2; do
check "fin du scénario : session EVPN vers ${rr} jamais coupée" sh -c "[ \"\$(vtysh -c 'show bgp neighbors ${rr}' | grep -o 'dropped [0-9]*')\" = \"\$(cat /tmp/t72.${rr})\" ]"
check "fin du scénario : session EVPN vers ${rr} jamais coupée" sh -c "[ \"\$(vtysh -c 'show bgp neighbors ${rr}' | grep -o 'dropped [0-9]*')\" = \"\$(cat /tmp/s10.${rr})\" ]"
done
first=$(log_gap /tmp/t72.log 0 "${T_UP}")
second=$(log_gap /tmp/t72.log "${T_UP}" 0)
stats=$(awk -F'icmp_seq=' '/bytes from/ {split($2, a, " "); n++; if (a[1] > max) max = a[1]} END {print n+0, max+0}' /tmp/t72.log)
gap=$(LC_ALL=C awk -F'[][]' '/bytes from/ {if (prev != "" && $2 - prev > max) max = $2 - prev; prev = $2} END {printf "%d", max * 10}' /tmp/s10.log)
stats=$(awk -F'icmp_seq=' '/bytes from/ {split($2, a, " "); n++; if (a[1] > max) max = a[1]} END {print n, max}' /tmp/s10.log)
received=${stats% *}
sent=${stats#* }
after=$(LC_ALL=C awk -F'[][]' -v from="${T_UP}" '/bytes from/ && $2 >= from' /tmp/t72.log | wc -l)
info "pendant tout le scénario : ${received} réponses pour ${sent} requêtes, $(( sent - received )) perdues ; première bascule : silence de $(( first / 10 )),$(( first % 10 )) s ; après le retour de ${MASTER} : ${after} réponses, silence de $(( second / 10 )),$(( second % 10 )) s"
check "première bascule de la passerelle en moins de 5 s" test "${first}" -lt 50
if [ "${EXPECTED}" = "${MASTER}" ]; then
check "seconde bascule (retour de ${MASTER}, le plus prioritaire) en moins de 5 s" test "${second}" -lt 50
else
check "retour de ${MASTER} sans seconde bascule (plus long silence < 5 s)" test "${second}" -lt 50
fi
info "pendant tout le scénario : ${received} réponses pour ${sent} requêtes, $(( sent - received )) perdues ; plus long silence : $(( gap / 10 )),$(( gap % 10 )) s"
check "bascule de la passerelle en moins de 5 s" test "${gap}" -lt 50
NODE

View file

@ -0,0 +1,53 @@
for host in hv1 hv2; do
on "${host}" "HOST=${host}" <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (${HOST})"; exit 0; }
KEY=$(vm_key)
case "${HOST}" in hv1) n=1 ;; hv2) n=2 ;; esac
check "${HOST} : VPC vp-s11, sans l3vni" vpc_create vp-s11 10.252.0.0/16
check "${HOST} : subnet sn-s11a (VNI 3111)" subnet_create sn-s11a vp-s11 3111 10.252.1.0/24
check "${HOST} : subnet sn-s11b (VNI 3112)" subnet_create sn-s11b vp-s11 3112 10.252.2.0/24
check "${HOST} : VM s11-a${n} 10.252.1.1${n}" vm_create "s11-a${n}" sn-s11a "10.252.1.1${n}" "${KEY}"
check "${HOST} : VM s11-b${n} 10.252.2.1${n}" vm_create "s11-b${n}" sn-s11b "10.252.2.1${n}" "${KEY}"
check "${HOST} : s11-a${n} joignable" vm_wait vp-s11 "10.252.1.1${n}"
check "${HOST} : s11-b${n} joignable" vm_wait vp-s11 "10.252.2.1${n}"
check "${HOST} : MAC anycast inscrite dans la FDB du bridge de sn-s11a" sh -c 'ip netns exec vp-s11 bridge fdb show br br-s11a | grep -qi "^$1 dev br-s11a master br-s11a permanent"' _ "$(anycast_mac 3111)"
check "${HOST} : le netns émet vers sn-s11a depuis la gateway 10.252.1.254" sh -c "ip -n vp-s11 -4 route get 10.252.1.1${n} | grep -q 'src 10.252.1.254 '"
NODE
done
on hv2 <<'NODE'
check "prérequis : s11-a2 résout sa gateway vers la MAC anycast" vm_grep vp-s11 10.252.1.12 'ping -n -c 1 -W 2 10.252.1.254 >/dev/null; ip neigh show 10.252.1.254' "lladdr $(anycast_mac 3111) "
rm -f /tmp/s11.log
nohup ip netns exec vp-s11 bash -c 'for i in $(seq 1 80); do if timeout 1 bash -c "</dev/tcp/10.252.1.12/22" 2>/dev/null; then echo "$(date +%T.%N) ok"; else echo "$(date +%T.%N) KO"; fi; sleep 0.5; done' > /tmp/s11.log 2>&1 &
sleep 3
NODE
on hv1 <<'NODE'
check "hv1 : entrées ARP du netns retirées sur sn-s11a" ip -n vp-s11 neigh flush dev br-s11a
check "s11-b1 (hv1) joint s11-a2 (hv2), autre subnet : relais L2 depuis l'adresse d'émission de hv1" vm_ssh vp-s11 10.252.2.11 'ping -n -c 3 -W 2 10.252.1.12'
NODE
on hv2 <<'NODE'
MAC=$(anycast_mac 3111)
check "fenêtre ouverte : s11-a2 associe l'adresse d'émission 10.252.1.253 à la MAC de hv1" vm_grep vp-s11 10.252.1.12 'ip neigh show 10.252.1.253' 'lladdr 02:03:c0:a8:0e:0b '
check "pendant la fenêtre : la gateway de s11-a2 reste la MAC anycast ${MAC}" vm_grep vp-s11 10.252.1.12 'ip neigh show 10.252.1.254' "lladdr ${MAC} "
check "pendant la fenêtre : métadonnées servies à s11-a2" vm_grep vp-s11 10.252.1.12 "python3 -c \"import urllib.request; print(urllib.request.urlopen('http://169.254.169.254/meta-data', timeout=5).read().decode())\"" 'instance-id: s11-a2'
BEFORE=$(vm_ssh vp-s11 10.252.1.12 'stat -c %Y /run/systemd/netif/leases/*')
sleep 2
check "pendant la fenêtre : renouvellement DHCP demandé" vm_ssh vp-s11 10.252.1.12 'sudo networkctl renew ens3'
renewed () {
local i
for i in $(seq 1 15); do
[ "$(vm_ssh vp-s11 10.252.1.12 'stat -c %Y /run/systemd/netif/leases/*')" != "${BEFORE}" ] && return 0
sleep 1
done
echo "bail non réécrit" >&2
return 1
}
check "pendant la fenêtre : bail renouvelé" renewed
check "bail tenu par la gateway 10.252.1.254" vm_grep vp-s11 10.252.1.12 'cat /run/systemd/netif/leases/*' 'SERVER_ADDRESS=10.252.1.254'
check "s11-a2 garde son adresse après le renouvellement" has_addr vp-s11 10.252.1.12
for i in $(seq 1 60); do [ "$(wc -l < /tmp/s11.log)" -ge 80 ] && break; sleep 1; done
info "connexions TCP du netns de hv2 vers s11-a2:22 : $(grep -c ' ok$' /tmp/s11.log) réussies, $(grep -c ' KO$' /tmp/s11.log) perdues ; $(grep ' KO$' /tmp/s11.log | head -3 | tr '\n' ' ')"
check "aucune connexion TCP du netns de hv2 vers sa VM perdue pendant la fenêtre (80/80)" test "$(grep -c ' ok$' /tmp/s11.log)" -eq 80
NODE

View file

@ -0,0 +1,36 @@
on hv1 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two"; exit 0; }
KEY=$(vm_key)
check "VPC vp-s2" vpc_create vp-s2 10.220.0.0/16
check "subnet sn-s2a, default_route absent" subnet_create sn-s2a vp-s2 2201 10.220.1.0/24
check "subnet sn-s2b, default_route et gateway 10.220.2.1" subnet_create sn-s2b vp-s2 2202 10.220.2.0/24 ',"default_route":true,"gateway":"10.220.2.1"'
check "sn-s2a : gateway calculée 10.220.1.254 et adresse d'émission 10.220.1.253" sh -c "curl -fsS ${API}/subnets/sn-s2a | jq -e '.interface_ip == \"10.220.1.254\" and .relay_ip == \"10.220.1.253\"'"
vm_refused () {
curl -s -X POST -H 'Content-Type: application/json' "${API}/vms" \
-d "{\"name\":\"s2-x\",\"memory\":512,\"cpus\":1,\"interfaces\":[{\"subnet\":\"sn-s2a\",\"ip\":\"${1}\",\"primary\":true}],\"storage\":[{\"path\":\"/nonexistent\",\"dev\":\"vda\"}]}" |
grep -q 'reserved by the subnet'
}
check "VM refusée sur la gateway calculée" vm_refused 10.220.1.254
check "VM refusée sur l'adresse d'émission" vm_refused 10.220.1.253
check "interface_ip fourni sur un subnet vxlan refusé" sh -c "curl -s -X POST -H 'Content-Type: application/json' -d '{\"name\":\"sn-s2x\",\"vpc\":\"vp-s2\",\"mode\":\"vxlan\",\"vxlan_id\":2203,\"iface_type\":\"vms\",\"interface_ip\":\"10.220.3.1\",\"cidr\":\"10.220.3.0/24\"}' ${API}/subnets | grep -q 'computed for vxlan'"
check "VM s2-a" vm_create s2-a sn-s2a 10.220.1.10 "${KEY}"
check "VM s2-b" vm_create s2-b sn-s2b 10.220.2.10 "${KEY}"
check "s2-a joignable" vm_wait vp-s2 10.220.1.10
check "s2-b joignable" vm_wait vp-s2 10.220.2.10
check "sn-s2a : route par défaut via la gateway 10.220.1.254" route_via vp-s2 10.220.1.10 default 10.220.1.254
check "sn-s2a : route vers la VPC via la gateway" route_via vp-s2 10.220.1.10 10.220.0.0/16 10.220.1.254
check "sn-s2a : route /32 vers les métadonnées via la gateway" route_via vp-s2 10.220.1.10 169.254.169.254 10.220.1.254
check "sn-s2b : route par défaut via la gateway explicite 10.220.2.1" route_via vp-s2 10.220.2.10 default 10.220.2.1
check "sn-s2b : route vers la VPC via la gateway du subnet, pas via la gateway explicite" route_via vp-s2 10.220.2.10 10.220.0.0/16 10.220.2.254
check "sn-s2b : route /32 vers les métadonnées via la gateway du subnet" route_via vp-s2 10.220.2.10 169.254.169.254 10.220.2.254
check "suppression de s2-a" vm_delete s2-a
check "suppression de sn-s2a" api_delete subnets/sn-s2a
check "sn-s2a supprimé" wait_state subnets/sn-s2a deleted
check "sn-s2a : plus de macvlan gw-s2a dans le netns" sh -c "! ip -n vp-s2 link show gw-s2a >/dev/null 2>&1"
check "sn-s2a recréé" subnet_create sn-s2a vp-s2 2201 10.220.1.0/24
check "VM s2-a2 sur le subnet recréé" vm_create s2-a2 sn-s2a 10.220.1.11 "${KEY}"
check "s2-a2 joignable" vm_wait vp-s2 10.220.1.11
check "après recréation : route par défaut via la gateway 10.220.1.254" route_via vp-s2 10.220.1.11 default 10.220.1.254
check "après recréation : route vers la VPC via la gateway" route_via vp-s2 10.220.1.11 10.220.0.0/16 10.220.1.254
check "après recréation : route /32 vers les métadonnées" route_via vp-s2 10.220.1.11 169.254.169.254 10.220.1.254
NODE

View file

@ -0,0 +1,16 @@
on hv1 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two"; exit 0; }
KEY=$(vm_key)
check "VPC vp-s3a" vpc_create vp-s3a 10.230.0.0/16
check "VPC vp-s3b" vpc_create vp-s3b 10.231.0.0/16
check "subnet sn-s3a" subnet_create sn-s3a vp-s3a 2301 10.230.1.0/24
check "subnet sn-s3b" subnet_create sn-s3b vp-s3b 2302 10.231.1.0/24
check "VM s3-x dans vp-s3a" vm_create s3-x sn-s3a 10.230.1.10 "${KEY}"
check "VM s3-y dans vp-s3b" vm_create s3-y sn-s3b 10.231.1.10 "${KEY}"
check "s3-x joignable depuis sa VPC" vm_wait vp-s3a 10.230.1.10
check "s3-y joignable depuis sa VPC (témoin : la cible est vivante)" vm_wait vp-s3b 10.231.1.10
check "s3-x joint sa passerelle (témoin)" vm_ssh vp-s3a 10.230.1.10 'ping -c 2 -W 2 10.230.1.254'
check "s3-x ne joint pas s3-y en ICMP" vm_fails vp-s3a 10.230.1.10 'ping -c 2 -W 2 10.231.1.10'
check "s3-x n'ouvre pas de connexion TCP vers s3-y:22" vm_fails vp-s3a 10.230.1.10 'timeout 5 bash -c "</dev/tcp/10.231.1.10/22"'
check "s3-y ne joint pas s3-x en ICMP" vm_fails vp-s3b 10.231.1.10 'ping -c 2 -W 2 10.230.1.10'
NODE

View file

@ -0,0 +1,25 @@
on hv1 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv1)"; exit 0; }
KEY=$(vm_key)
check "hv1 : VPC vp-s4" vpc_create vp-s4 10.240.0.0/16
check "hv1 : subnet sn-s4" subnet_create sn-s4 vp-s4 2401 10.240.1.0/24
check "hv1 : vxlan-2401 porte l'adresse VTEP locale 192.168.14.11" sh -c "ip -d link show vxlan-2401 | grep -q 'local 192.168.14.11 '"
check "hv1 : VM s4-p" vm_create s4-p sn-s4 10.240.1.10 "${KEY}"
NODE
on hv2 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv2)"; exit 0; }
check "hv2 : VPC vp-s4" vpc_create vp-s4 10.240.0.0/16
check "hv2 : subnet sn-s4" subnet_create sn-s4 vp-s4 2401 10.240.1.0/24
check "hv2 : vxlan-2401 porte l'adresse VTEP locale 192.168.14.12" sh -c "ip -d link show vxlan-2401 | grep -q 'local 192.168.14.12 '"
check "hv2 : VM s4-q" vm_create s4-q sn-s4 10.240.1.11
NODE
on hv1 <<'NODE'
check "s4-p joignable" vm_wait vp-s4 10.240.1.10
for i in $(seq 1 30); do vtysh -c "show evpn vni 2401" | grep -q 192.168.14.12 && break; sleep 2; done
check "hv1 : VTEP distant 192.168.14.12 appris par EVPN pour la VNI 2401" sh -c "vtysh -c 'show evpn vni 2401' | grep -q '192.168.14.12'"
check "hv1 : entrée d'inondation vers 192.168.14.12" sh -c "bridge fdb show dev vxlan-2401 | grep -q '00:00:00:00:00:00 dst 192.168.14.12'"
for i in $(seq 1 24); do vm_ssh vp-s4 10.240.1.10 'ping -c 1 -W 2 10.240.1.11' >/dev/null 2>&1 && break; sleep 5; done
check "s4-p (hv1) joint s4-q (hv2)" vm_ssh vp-s4 10.240.1.10 'ping -c 3 -W 2 10.240.1.11'
check "trame pleine taille : 1472 octets en -M do" vm_ssh vp-s4 10.240.1.10 'ping -M do -s 1472 -c 2 -W 2 10.240.1.11'
check "1473 octets refusés localement (MTU 1500)" vm_grep vp-s4 10.240.1.10 'ping -M do -s 1473 -c 1 -W 2 10.240.1.11' 'message too long'
NODE

View file

@ -0,0 +1,23 @@
on hv1 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv1)"; exit 0; }
KEY=$(vm_key)
check "hv1 : VPC vp-s5a" vpc_create vp-s5a 10.245.0.0/16
check "hv1 : subnet sn-s5a (VNI 2501)" subnet_create sn-s5a vp-s5a 2501 10.245.1.0/24
check "hv1 : VM s5-r dans vp-s5a" vm_create s5-r sn-s5a 10.245.1.10 "${KEY}"
NODE
on hv2 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv2)"; exit 0; }
check "hv2 : VPC vp-s5a" vpc_create vp-s5a 10.245.0.0/16
check "hv2 : subnet sn-s5a (VNI 2501)" subnet_create sn-s5a vp-s5a 2501 10.245.1.0/24
check "hv2 : VM s5-t dans vp-s5a (témoin)" vm_create s5-t sn-s5a 10.245.1.12
check "hv2 : VPC vp-s5b, même plage" vpc_create vp-s5b 10.245.0.0/16
check "hv2 : subnet sn-s5b (VNI 2502), même plage" subnet_create sn-s5b vp-s5b 2502 10.245.1.0/24
check "hv2 : VM s5-s dans vp-s5b" vm_create s5-s sn-s5b 10.245.1.11
NODE
on hv1 <<'NODE'
check "s5-r joignable" vm_wait vp-s5a 10.245.1.10
for i in $(seq 1 24); do vm_ssh vp-s5a 10.245.1.10 'ping -c 1 -W 2 10.245.1.12' >/dev/null 2>&1 && break; sleep 5; done
check "s5-r joint s5-t, même VPC sur hv2 (témoin)" vm_ssh vp-s5a 10.245.1.10 'ping -c 3 -W 2 10.245.1.12'
check "s5-r ne joint pas s5-s, autre VPC sur hv2, même plage" vm_fails vp-s5a 10.245.1.10 'ping -c 3 -W 2 10.245.1.11'
check "aucune entrée ARP résolue pour 10.245.1.11 dans s5-r" vm_fails vp-s5a 10.245.1.10 'ip neigh show 10.245.1.11 | grep -q lladdr'
NODE

View file

@ -1,28 +1,10 @@
# fonctionnalité: perte d'un route reflector — l'autre garde la session EVPN, le VTEP distant reste connu, le trafic L2 entre hôtes passe sans perte mesurable, retour du RR arrêté
# hôtes: hv1 hv2
# tickets: #54
on hv1 <<'NODE'
KEY=$(vm_key)
check "hv1 : VPC vp-t71" vpc_create vp-t71 10.71.0.0/16
check "hv1 : subnet sn-t71 (VNI 7101)" subnet_create sn-t71 vp-t71 7101 10.71.1.0/24
check "hv1 : VM t71-p" vm_create t71-p sn-t71 10.71.1.10 "${KEY}"
NODE
on hv2 <<'NODE'
check "hv2 : VPC vp-t71" vpc_create vp-t71 10.71.0.0/16
check "hv2 : subnet sn-t71 (VNI 7101)" subnet_create sn-t71 vp-t71 7101 10.71.1.0/24
check "hv2 : VM t71-q" vm_create t71-q sn-t71 10.71.1.11
check "hv2 : t71-q répond depuis son netns" netns_ping_wait vp-t71 10.71.1.11
NODE
on hv1 <<'NODE'
check "prérequis : t71-p joignable" vm_wait vp-t71 10.71.1.10
check "prérequis : VM s4-p de S4 en marche" test "$(api_state vms/s4-p)" = running
for rr in 10.255.255.1 10.255.255.2; do
check "session EVPN de hv1 vers ${rr} établie" sh -c "vtysh -c 'show bgp neighbors ${rr}' | grep -q 'BGP state = Established'"
done
for i in $(seq 1 24); do vm_ssh vp-t71 10.71.1.10 'ping -c 1 -W 2 10.71.1.11' >/dev/null 2>&1 && break; sleep 5; done
check "prérequis : t71-p joint t71-q" vm_ssh vp-t71 10.71.1.10 'ping -c 2 -W 2 10.71.1.11'
vm_ssh vp-t71 10.71.1.10 'rm -f /tmp/t71.log; nohup ping -D -i 0.2 10.71.1.11 > /tmp/t71.log 2>&1 &'
check "prérequis : s4-p joint s4-q" vm_ssh vp-s4 10.240.1.10 'ping -c 2 -W 2 10.240.1.11'
vm_ssh vp-s4 10.240.1.10 'rm -f /tmp/s6.log; nohup ping -D -i 0.2 10.240.1.11 > /tmp/s6.log 2>&1 &'
sleep 5
NODE
@ -33,10 +15,10 @@ check "${NODE_NAME} : arrêt de FRR" systemctl stop frr
NODE
sleep 30
on hv1 "NODE_NAME=${node}" "LOST=${lost}" "KEPT=${kept}" <<'NODE'
recent () { vm_ssh vp-t71 10.71.1.10 "now=\$(date +%s); awk -F'[][]' -v now=\$now '/bytes from/ && \$2 > now - ${1}' /tmp/t71.log | wc -l"; }
recent () { vm_ssh vp-s4 10.240.1.10 "now=\$(date +%s); awk -F'[][]' -v now=\$now '/bytes from/ && \$2 > now - ${1}' /tmp/s6.log | wc -l"; }
check "${NODE_NAME} arrêté : session vers ${LOST} tombée" sh -c "! vtysh -c 'show bgp neighbors ${LOST}' | grep -q 'BGP state = Established'"
check "${NODE_NAME} arrêté : session vers ${KEPT} toujours établie" sh -c "vtysh -c 'show bgp neighbors ${KEPT}' | grep -q 'BGP state = Established'"
check "${NODE_NAME} arrêté : VTEP distant toujours connu" sh -c "vtysh -c 'show evpn vni 7101' | grep -q 192.168.14.12"
check "${NODE_NAME} arrêté : VTEP distant toujours connu" sh -c "vtysh -c 'show evpn vni 2401' | grep -q 192.168.14.12"
n=$(recent 10)
info "${NODE_NAME} arrêté depuis 30 s : ${n} réponses dans les 10 dernières secondes (50 si le trafic passe intégralement)"
check "${NODE_NAME} arrêté : le trafic passe (au moins 45 réponses sur 50)" test "${n}" -ge 45
@ -56,9 +38,9 @@ NODE
done
on hv1 <<'NODE'
vm_ssh vp-t71 10.71.1.10 'pkill -x ping' || true
vm_ssh vp-s4 10.240.1.10 'pkill -x ping' || true
sleep 1
stats=$(vm_ssh vp-t71 10.71.1.10 "awk -F'icmp_seq=' '/bytes from/ {split(\$2, a, \" \"); n++; if (a[1] > max) max = a[1]} END {print n, max}' /tmp/t71.log")
stats=$(vm_ssh vp-s4 10.240.1.10 "awk -F'icmp_seq=' '/bytes from/ {split(\$2, a, \" \"); n++; if (a[1] > max) max = a[1]} END {print n, max}' /tmp/s6.log")
received=${stats% *}
sent=${stats#* }
info "pendant tout le scénario : ${received} réponses pour ${sent} requêtes, $(( sent - received )) perdues"

View file

@ -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.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.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.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 la gateway (DHCP)" route_via vp-s7 10.241.1.10 10.241.0.0/16 10.241.1.254
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.254)" 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.254 .*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

View file

@ -0,0 +1,100 @@
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.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.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.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'
MAC=$(anycast_mac 2811)
R=$(vtysh -c 'show bgp l2vpn evpn route type macip')
check "rr1 : routes EVPN de type 2 reçues (témoin)" sh -c 'echo "$1" | grep -q "\[2\]:"' _ "${R}"
check "rr1 : aucune route de type 2 pour la MAC anycast de sn-s8s (${MAC}), présente sur hv1 et hv2" sh -c '! echo "$1" | grep -qi "$2"' _ "${R}" "${MAC}"
NODE
on hv1 <<'NODE'
MAC=$(anycast_mac 2811)
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}'"
check "hv1 : table EVPN de la VNI 2811 non vide (témoin)" sh -c "vtysh -c 'show evpn mac vni 2811' | grep -qiE '([0-9a-f]{2}:){5}[0-9a-f]{2}'"
check "hv1 : MAC anycast ${MAC} absente de la table EVPN de la VNI 2811" sh -c '! vtysh -c "show evpn mac vni 2811" | grep -qi "$1"' _ "${MAC}"
NODE
on hv3 <<'NODE'
for i in $(seq 1 30); do [ "$(bgp_paths vp-s8 10.242.1.50/32)" -ge 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

View file

@ -1,21 +1,18 @@
# fonctionnalité: subnets vxlan partagés par deux hôtes, deux VM par hôte, dans une VPC avec et une VPC sans l3vni — toutes les paires, gateway anycast vue par chaque VM et absente d'EVPN, aucune MAC en double
# hôtes: hv2 hv3
# tickets: #57, #41
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-t43r, l3vni 4300" vpc_create vp-t43r 10.43.0.0/18 4300
check "${HOST} : subnet sn-t43r1 (VNI 4311)" subnet_create sn-t43r1 vp-t43r 4311 10.43.1.0/24
check "${HOST} : subnet sn-t43r2 (VNI 4312)" subnet_create sn-t43r2 vp-t43r 4312 10.43.2.0/24
check "${HOST} : VM t43-r1-${n} 10.43.1.1${n}" vm_create "t43-r1-${n}" sn-t43r1 "10.43.1.1${n}" "${KEY}"
check "${HOST} : VM t43-r2-${n} 10.43.2.1${n}" vm_create "t43-r2-${n}" sn-t43r2 "10.43.2.1${n}" "${KEY}"
check "${HOST} : VPC vp-t43n, sans l3vni" vpc_create vp-t43n 10.43.64.0/18
check "${HOST} : subnet sn-t43n1 (VNI 4321)" subnet_create sn-t43n1 vp-t43n 4321 10.43.65.0/24
check "${HOST} : subnet sn-t43n2 (VNI 4322)" subnet_create sn-t43n2 vp-t43n 4322 10.43.66.0/24
check "${HOST} : VM t43-n1-${n} 10.43.65.1${n}" vm_create "t43-n1-${n}" sn-t43n1 "10.43.65.1${n}" "${KEY}"
check "${HOST} : VM t43-n2-${n} 10.43.66.1${n}" vm_create "t43-n2-${n}" sn-t43n2 "10.43.66.1${n}" "${KEY}"
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.0/24
check "${HOST} : subnet sn-s9r2 (VNI 2912)" subnet_create sn-s9r2 vp-s9r 2912 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.0/24
check "${HOST} : subnet sn-s9n2 (VNI 2922)" subnet_create sn-s9n2 vp-s9n 2922 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
@ -23,18 +20,18 @@ for host in hv2 hv3; do
on "${host}" "HOST=${host}" <<'NODE'
case "${HOST}" in hv2) n=1 ;; hv3) n=2 ;; esac
for v in r n; do
vpc="vp-t43${v}"
case "${v}" in r) base=0 vni=431 ;; n) base=64 vni=432 ;; esac
vpc="vp-s9${v}"
net="10.25$([ "${v}" = r ] && echo 0 || echo 1)"
for s in 1 2; do
src="10.43.$(( base + s )).1${n}"
gw="10.43.$(( base + s )).254"
mac=$(anycast_mac "${vni}${s}")
src="${net}.${s}.1${n}"
gw="${net}.${s}.254"
mac=$(anycast_mac "29$([ "${v}" = r ] && echo 1 || echo 2)${s}")
check "${HOST} : ${src} joignable" vm_wait "${vpc}" "${src}"
check "${HOST} : ${src} joint sa gateway ${gw}" vm_ssh "${vpc}" "${src}" "ping -n -c 2 -W 2 ${gw}"
check "${HOST} : ${src} voit la MAC anycast de la gateway (${mac})" vm_grep "${vpc}" "${src}" "ip neigh show ${gw}" "lladdr ${mac} "
for d in 1 2; do
for m in 1 2; do
dst="10.43.$(( base + d )).1${m}"
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'))" \
@ -43,7 +40,7 @@ for v in r n; do
done
done
done
for vni in 4311 4312 4321 4322; do
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}'"
check "${HOST} : MAC anycast $(anycast_mac "${vni}") absente de la table EVPN de la VNI ${vni}" sh -c '! vtysh -c "show evpn mac vni $1" | grep -qi "$2"' _ "${vni}" "$(anycast_mac "${vni}")"
done

View file

@ -1,41 +0,0 @@
# fonctionnalité: socle du lab — underlay, passerelle VRRP, sessions EVPN, base BGP posée par l'agent, backend DHCP, watchdog silencieux
# hôtes: hv1 hv2 hv3
# tickets: #50, #51, #54, #41
vrrp_state () {
on "${1}" <<'NODE' | sed -n 's/^VRRP: //p'
echo "VRRP: $(vtysh -c 'show vrrp' | awk '/Status \(v4\)/ {print $3}')"
NODE
}
SW1=$(vrrp_state sw1)
SW2=$(vrrp_state sw2)
for host in hv1 hv2 hv3; do
case "${host}" in
hv1) addr=192.168.14.11 backend=two ;;
hv2) addr=192.168.14.12 backend=dnsmasq ;;
hv3) addr=192.168.14.13 backend=dnsmasq ;;
esac
on "${host}" "HOST=${host}" "ADDR=${addr}" "BACKEND=${backend}" "SW1=${SW1}" "SW2=${SW2}" <<'NODE'
check "${HOST} : agent actif" systemctl is-active --quiet agent
check "${HOST} : API de l'agent joignable" curl -fsS -o /dev/null "${API}/vpcs"
check "${HOST} : backend DHCP ${BACKEND} configuré" grep -A1 -x 'dhcp:' /etc/two/agent.yml | grep -qx " backend: ${BACKEND}"
check "${HOST} : VTEP = adresse underlay ${ADDR}" test "$(vtep_host)" = "${ADDR}"
for peer in 192.168.14.11 192.168.14.12 192.168.14.13; do
[ "${peer}" = "${ADDR}" ] && continue
check "${HOST} : underlay, ${peer} joignable" ping -c 2 -W 2 "${peer}"
done
check "${HOST} : un seul maître VRRP sur la passerelle (sw1 ${SW1}, sw2 ${SW2})" sh -c "[ \"\$1 \$2\" = 'Master Backup' ] || [ \"\$1 \$2\" = 'Backup Master' ]" _ "${SW1}" "${SW2}"
check "${HOST} : passerelle 192.168.14.1 joignable" ping -c 2 -W 2 192.168.14.1
for rr in 10.255.255.1 10.255.255.2; do
check "${HOST} : base BGP de l'agent, ${rr} dans le peer-group fabric de frr.conf" grep -qx " neighbor ${rr} peer-group fabric" /etc/frr/frr.conf
check "${HOST} : session EVPN vers ${rr} établie" sh -c "vtysh -c 'show bgp neighbors ${rr}' | grep -q 'BGP state = Established'"
check "${HOST} : loopback de ${rr} joignable" ping -c 2 -W 2 "${rr}"
done
check "${HOST} : aucune incohérence signalée par le watchdog depuis 5 min (hors réservation DHCP périmée, #78)" watchdog_quiet 300 'stale dhcp reservation'
known_flaky "#78" "${HOST} : aucune réservation DHCP signalée périmée par le watchdog depuis 5 min" watchdog_quiet_about 300 'stale dhcp reservation'
check "${HOST} : image de VM compatible two prête" two_image
check "${HOST} : clé SSH des VM prête" vm_key
NODE
done

View file

@ -1,46 +0,0 @@
# fonctionnalité: hypothèses d'environnement de la suite — firmware UEFI, unités modèles de l'agent, journalctl, format de ebtables -L, br-lan, priorités VRRP lues dans FRR
# hôtes: hv1 hv2 hv3
# tickets: #70
for sw in sw1 sw2; do
on "${sw}" "SW=${sw}" <<'NODE'
check "${SW} : ligne « vrrp <N> priority <P> » dans la running-config de FRR (lue par 72)" sh -c "vtysh -c 'show running-config' | awk '\$1 == \"vrrp\" && \$3 == \"priority\" && \$4 ~ /^[0-9]+\$/ {f = 1} END {exit !f}'"
NODE
done
for host in hv1 hv2 hv3; do
on "${host}" "HOST=${host}" <<'NODE'
for f in /usr/share/OVMF/OVMF_CODE.fd /usr/share/OVMF/OVMF_VARS.fd; do
check "${HOST} : firmware UEFI ${f} présent (défaut de qemu.ovmf_code_path / ovmf_vars_template)" test -r "${f}"
done
check "${HOST} : journalctl accepte --since @<epoch>" journalctl --since "@$(date +%s)" -n 0 --no-pager -q
for unit in dhcp@.service dnsmasq@.service metadata@.service; do
check "${HOST} : unité modèle ${unit} installée" systemctl cat "${unit}"
done
NS=t02-ebt
MAC=02:01:00:00:0c:27
ip netns add "${NS}"
check "${HOST} : ebtables -L, aucune règle avant (témoin)" test "$(ebt_confined "${NS}" v-t02-i "${MAC}")" -eq 0
ip netns exec "${NS}" ebtables -t nat -A PREROUTING --in-interface v-t02-i -s "${MAC}" -j DROP
ip netns exec "${NS}" ebtables -t filter -A FORWARD --out-interface v-t02-i -s "${MAC}" -j DROP
ip netns exec "${NS}" ebtables -t filter -A OUTPUT --out-interface v-t02-i -s "${MAC}" -j DROP
ip netns exec "${NS}" ebtables -A FORWARD --out-interface v-t02-i -p arp --arp-op Request --arp-ip-dst 10.2.1.254 -j DROP
ip netns exec "${NS}" ebtables -A FORWARD --out-interface v-t02-i -p IPv4 --ip-protocol udp --ip-source-port 67:68 --ip-destination-port 67:68 --ip-source 10.2.1.254 -j DROP
check "${HOST} : ebtables -L, confinement de MAC lu par ebt_confined (3 règles)" test "$(ebt_confined "${NS}" v-t02-i "${MAC}")" -eq 3
check "${HOST} : ebtables -L, blocage ARP vers la gateway lu par ebt_arp_drop" ebt_arp_drop "${NS}" v-t02-i 10.2.1.254
check "${HOST} : ebtables -L, blocage DHCP lu par ebt_dhcp_drop" ebt_dhcp_drop "${NS}" v-t02-i 10.2.1.254
other_ip_ignored () { ! ebt_arp_drop "${NS}" v-t02-i 10.2.1.25; }
check "${HOST} : ebt_arp_drop ne confond pas une autre adresse (témoin)" other_ip_ignored
ip netns del "${NS}"
case "${HOST}" in
hv1) LAN=10.33.0.11 ;;
hv2) LAN=10.33.0.12 ;;
*) LAN="" ;;
esac
if [ -n "${LAN}" ]; then
check "${HOST} : br-lan porte l'adresse de l'hôte ${LAN}/24" sh -c "ip -4 -o addr show dev br-lan | grep -q ' ${LAN}/24 '"
check "${HOST} : lan rattachée à br-lan" sh -c "ip -o link show lan | grep -q 'master br-lan'"
check "${HOST} : aucune adresse IPv4 restée sur lan (gestionnaire réseau de l'image)" sh -c "! ip -4 -o addr show dev lan | grep -q inet"
fi
NODE
done

View file

@ -1,24 +0,0 @@
# fonctionnalité: hypothèses sur l'image de VM — outils (curl, python3), nom d'interface, effet réel de network-config, forme du compte verrouillé
# hôtes: hv1
# tickets: #70
on hv1 <<'NODE'
KEY=$(vm_key)
check "VPC vp-t03" vpc_create vp-t03 10.3.0.0/16
check "subnet sn-t03a (VNI 301)" subnet_create sn-t03a vp-t03 301 10.3.1.0/24
check "VM t03-a (sshkey seule)" vm_create t03-a sn-t03a 10.3.1.10 "${KEY}"
check "t03-a joignable" vm_wait vp-t03 10.3.1.10
for tool in curl python3; do
check "t03-a : ${tool} présent dans l'image (utilisé par 23 et 35)" vm_ssh vp-t03 10.3.1.10 "command -v ${tool}"
done
check "t03-a : interface ens3 présente (nom supposé par la suite)" vm_ssh vp-t03 10.3.1.10 'test -e /sys/class/net/ens3'
check "t03-a : aucune interface eth0" vm_ssh vp-t03 10.3.1.10 '! test -e /sys/class/net/eth0'
check "network-config servi à t03-a : vise eth0" vm_grep vp-t03 10.3.1.10 'curl -fsS http://169.254.169.254/network-config' 'eth0:'
NETFILE=$(vm_ssh vp-t03 10.3.1.10 'networkctl status ens3' | sed -n 's/^ *Network File: *//p')
info "t03-a : ens3 configurée par ${NETFILE:-aucun fichier networkd}"
check "t03-a : ens3 configurée par systemd-networkd (fichier : ${NETFILE:-aucun})" test -n "${NETFILE}"
not_eth0_file () { case "${NETFILE}" in ""|*eth0*) return 1 ;; esac; }
check "hypothèse : ens3 tient sa configuration de l'image, pas de network-config, qui vise eth0 (fichier : ${NETFILE:-aucun})" not_eth0_file
SHADOW=$(vm_ssh vp-t03 10.3.1.10 "sudo awk -F: '\$1 == \"syonad\" {print substr(\$2, 1, 1)}' /etc/shadow")
check "t03-a : compte syonad verrouillé (lock_passwd), champ de /etc/shadow commençant par « ! » (forme lue par 23 ; lu : « ${SHADOW} »)" test "${SHADOW}" = '!'
NODE

View file

@ -1,47 +0,0 @@
# fonctionnalité: validation de l'API — refus synchrones (400, 409, 422) des VPC, subnets et VM, sans trace en base
# hôtes: hv1
# tickets: #41, #57, #33
on hv1 <<'NODE'
check "VPC vp-t11a, l3vni 1100 (témoin)" vpc_create vp-t11a 10.11.0.0/16 1100
check "VPC : nom déjà pris, 409" expect_code 409 api_post_code vpcs '{"name":"vp-t11a","cidr":"10.11.0.0/16"}'
check "VPC : cidr invalide, 400" expect_code 400 api_post_code vpcs '{"name":"vp-t11x","cidr":"10.11.0.0/33"}'
check "VPC : l3vni 1100 déjà prise par vp-t11a, 409" expect_code 409 api_post_code vpcs '{"name":"vp-t11x","cidr":"10.12.0.0/16","l3vni":1100}'
for vni in 0 253 254 255 65536; do
check "VPC : l3vni ${vni} refusée, 400" expect_code 400 api_post_code vpcs "{\"name\":\"vp-t11x\",\"cidr\":\"10.12.0.0/16\",\"l3vni\":${vni}}"
done
check "VPC refusées : aucune trace de vp-t11x" expect_code 404 api_code GET vpcs/vp-t11x
check "subnet sn-t11a 10.11.1.0/24, VNI 1101 (témoin)" subnet_create sn-t11a vp-t11a 1101 10.11.1.0/24
check "subnet sn-t11g 10.11.2.0/24, VNI 1102, gateway explicite 10.11.2.1 (témoin)" subnet_create sn-t11g vp-t11a 1102 10.11.2.0/24 ',"default_route":true,"gateway":"10.11.2.1"'
check "sn-t11a : gateway calculée .254" test "$(api_field subnets/sn-t11a interface_ip)" = 10.11.1.254
check "sn-t11a : adresse d'émission calculée .253" test "$(api_field subnets/sn-t11a relay_ip)" = 10.11.1.253
check "subnet : nom déjà pris, 409" expect_code 409 api_post_code subnets '{"name":"sn-t11a","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1101,"cidr":"10.11.1.0/24"}'
check "subnet : mode inconnu, 422" expect_code 422 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vlan","vxlan_id":1109,"cidr":"10.11.9.0/24"}'
check "subnet : interface_ip fournie en vxlan, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/24","interface_ip":"10.11.9.1"}'
check "subnet : interface_ip absente en bridge, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"bridge","cidr":"10.11.9.0/24"}'
check "subnet : préfixe /30 en vxlan, 422" expect_code 422 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/30"}'
check "subnet : préfixe /29 en vxlan accepté (témoin)" expect_code 202 api_post_code subnets '{"name":"sn-t11p","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1103,"cidr":"10.11.3.0/29"}'
check "subnet : cidr avec bits d'hôte, 422" expect_code 422 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.1/24"}'
check "subnet : VPC inconnue, 422" expect_code 422 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11z","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/24"}'
check "subnet : champ cidr manquant, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109}'
check "subnets refusés : aucune trace de sn-t11x" expect_code 404 api_code GET subnets/sn-t11x
check "sn-t11p running" wait_state subnets/sn-t11p running
mkdir -p "${VOLUMES}"
check "VM t11-ok sur 10.11.1.10 (témoin)" vm_create t11-ok sn-t11a 10.11.1.10
check "VM : nom déjà pris, 409" expect_code 409 api_post_code vms "$(vm_body t11-ok sn-t11a 10.11.1.11)"
NONE="${VOLUMES}/t11-absent.qcow2"
for case in "gateway calculée:sn-t11a:10.11.1.254" "adresse d'émission:sn-t11a:10.11.1.253" "adresse de réseau:sn-t11a:10.11.1.0" \
"broadcast:sn-t11a:10.11.1.255" "hors du CIDR:sn-t11a:10.11.9.10" "gateway explicite:sn-t11g:10.11.2.1"; do
label=${case%%:*} rest=${case#*:}
check "VM refusée sur ${label} (${rest#*:}), 422" expect_code 422 api_post_code vms "$(vm_body t11-x "${rest%%:*}" "${rest#*:}" "${NONE}")"
done
check "VM : subnet inconnu, 422" expect_code 422 api_post_code vms "$(vm_body t11-x sn-t11z 10.11.1.12 "${NONE}")"
check "VM : aucune interface primaire, 400" expect_code 400 api_post_code vms "$(vm_body t11-x sn-t11a 10.11.1.12 "${NONE}" | sed 's/"primary":true/"primary":false/')"
check "VM : user_data en base64 invalide, 400" expect_code 400 api_post_code vms "$(vm_body t11-x sn-t11a 10.11.1.12 "${NONE}" '{"user_data":"pas du base64 !"}')"
check "VMs refusées : aucune trace de t11-x" expect_code 404 api_code GET vms/t11-x
cp "${TWO_IMAGE}" "${VOLUMES}/t11-ud.qcow2"
check "VM t11-ud avec user_data en base64 valide, 202 (témoin)" expect_code 202 api_post_code vms "$(vm_body t11-ud sn-t11a 10.11.1.12 "" "{\"user_data\":\"$(printf '#cloud-config\n' | base64 | tr -d '\n')\"}")"
check "t11-ud running" wait_state vms/t11-ud running
NODE

View file

@ -1,42 +0,0 @@
# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom
# hôtes: hv1
# tickets: #41
on hv1 <<'NODE'
check "VPC vp-t12a" vpc_create vp-t12a 10.12.0.0/16
mkdir -p "${VOLUMES}"
cp "${TWO_IMAGE}" "${VOLUMES}/t12-a.qcow2"
post_both () { api_post subnets "${1}" && api_post vms "${2}"; }
check "subnet sn-t12a et VM t12-a envoyés sans attendre" post_both \
'{"name":"sn-t12a","vpc":"vp-t12a","mode":"vxlan","vxlan_id":1201,"iface_type":"vms","cidr":"10.12.1.0/24"}' \
"$(vm_body t12-a sn-t12a 10.12.1.10)"
STATE=$(api_state vms/t12-a)
CODE=$(api_code DELETE vms/t12-a)
check "t12-a en creating au moment de la suppression (témoin de la fenêtre)" test "${STATE}" = creating
check "suppression de t12-a pendant creating refusée, 409" test "${CODE}" = 409
check "t12-a atteint running malgré la suppression refusée" wait_state vms/t12-a running
check "suppression de sn-t12a refusée tant que t12-a l'utilise, 409" expect_code 409 api_code DELETE subnets/sn-t12a
check "suppression de vp-t12a refusée tant que sn-t12a existe, 409" expect_code 409 api_code DELETE vpcs/vp-t12a
check "suppression d'une VM inconnue, 404" expect_code 404 api_code DELETE vms/t12-inconnue
check "suppression d'un subnet inconnu, 404" expect_code 404 api_code DELETE subnets/sn-t12z
check "suppression d'une VPC inconnue, 404" expect_code 404 api_code DELETE vpcs/vp-t12z
check "VM t12-err sur un disque absent : acceptée, 202 (pas de refus synchrone)" expect_code 202 api_post_code vms "$(vm_body t12-err sn-t12a 10.12.1.11 "${VOLUMES}/t12-absent.qcow2")"
check "t12-err passe en error" wait_state vms/t12-err error
check "suppression de t12-err depuis error, 202" expect_code 202 api_code DELETE vms/t12-err
check "t12-err supprimée" wait_state vms/t12-err deleted
check "t12-err : aucune unité two-vm-t12-err" sh -c '! systemctl list-units --all --plain --no-legend "two-vm-t12-err*" | grep -q .'
check "suppression de t12-a" vm_delete t12-a
check "t12-a recréée sous le même nom" vm_create t12-a sn-t12a 10.12.1.10
check "suppression de t12-a recréée" vm_delete t12-a
check "suppression de sn-t12a, plus utilisé, 202 (témoin)" expect_code 202 api_code DELETE subnets/sn-t12a
check "sn-t12a supprimé" wait_state subnets/sn-t12a deleted
check "sn-t12a recréé sous le même nom" subnet_create sn-t12a vp-t12a 1201 10.12.1.0/24
check "suppression de sn-t12a recréé" expect_code 202 api_code DELETE subnets/sn-t12a
check "sn-t12a recréé puis supprimé" wait_state subnets/sn-t12a deleted
check "suppression de vp-t12a, sans subnet, 202 (témoin)" expect_code 202 api_code DELETE vpcs/vp-t12a
check "vp-t12a supprimée" wait_state vpcs/vp-t12a deleted
check "vp-t12a recréée sous le même nom" vpc_create vp-t12a 10.12.0.0/16
NODE

View file

@ -1,42 +0,0 @@
# fonctionnalité: DHCP par le serveur intégré (backend two) — bail, server-id, renouvellement, option 121, un serveur par subnet, démarrages simultanés
# hôtes: hv1
# tickets: #46, #57
on hv1 <<'NODE'
KEY=$(vm_key)
check "VPC vp-t21" vpc_create vp-t21 10.21.0.0/16
check "subnet sn-t21a" subnet_create sn-t21a vp-t21 2101 10.21.1.0/24
check "subnet sn-t21b" subnet_create sn-t21b vp-t21 2102 10.21.2.0/24
check "backend two : socket de contrôle de sn-t21a" test -S /run/two/dhcp/vp-t21_br-t21a.sock
check "backend two : socket de contrôle de sn-t21b" test -S /run/two/dhcp/vp-t21_br-t21b.sock
check "backend two : aucune instance dnsmasq pour sn-t21a" sh -c '! systemctl is-active --quiet dnsmasq@vp-t21_br-t21a.service && [ ! -e /etc/dnsmasq.d/vp-t21_br-t21a.conf ]'
check "VM t21-a1, démarrée seule" vm_create t21-a1 sn-t21a 10.21.1.10 "${KEY}"
check "VM t21-a1 joignable" vm_wait vp-t21 10.21.1.10
check "VM t21-b1, démarrée seule" vm_create t21-b1 sn-t21b 10.21.2.10 "${KEY}"
check "VM t21-b1 joignable" vm_wait vp-t21 10.21.2.10
vm_create t21-a2 sn-t21a 10.21.1.11 "${KEY}" > /tmp/t21-a2.log 2>&1 & A=$!
vm_create t21-b2 sn-t21b 10.21.2.11 "${KEY}" > /tmp/t21-b2.log 2>&1 & B=$!
wait "${A}"; RA=$?
wait "${B}"; RB=$?
check "VM t21-a2, démarrée en même temps que t21-b2" test "${RA}" -eq 0
check "VM t21-b2, démarrée en même temps que t21-a2" test "${RB}" -eq 0
for vm in 10.21.1.10:10.21.1.254 10.21.1.11:10.21.1.254 10.21.2.10:10.21.2.254 10.21.2.11:10.21.2.254; do
ip=${vm%%:*}; gw=${vm#*:}
check "${ip} joignable" vm_wait vp-t21 "${ip}"
check "${ip} : adresse de son propre subnet" has_addr vp-t21 "${ip}"
check "${ip} : bail DHCP tenu par systemd-networkd" vm_ssh vp-t21 "${ip}" 'ls /run/systemd/netif/leases/ | grep -q .'
check "${ip} : bail servi par la gateway ${gw} (server-id)" test "$(vm_lease vp-t21 "${ip}" SERVER_ADDRESS)" = "${gw}"
check "${ip} : route par défaut via ${gw}" route_via vp-t21 "${ip}" default "${gw}"
check "${ip} : route vers la VPC via ${gw}" route_via vp-t21 "${ip}" 10.21.0.0/16 "${gw}"
check "${ip} : route /32 vers les métadonnées via ${gw}" route_via vp-t21 "${ip}" 169.254.169.254 "${gw}"
done
check "10.21.1.10 : bail renouvelé (networkctl renew)" lease_renewed vp-t21 10.21.1.10
check "10.21.1.10 : même adresse après le renouvellement" has_addr vp-t21 10.21.1.10
check "10.21.1.10 : renouvellement servi par la gateway" test "$(vm_lease vp-t21 10.21.1.10 SERVER_ADDRESS)" = 10.21.1.254
vm_host () { echo "$(vm_ssh vp-t21 "${1}" 'cat /sys/class/net/ens3/address')=${1}"; }
A_HOSTS=$(printf '%s\n' "$(vm_host 10.21.1.10)" "$(vm_host 10.21.1.11)" | sort | tr '\n' ' ' | sed 's/ $//')
B_HOSTS=$(printf '%s\n' "$(vm_host 10.21.2.10)" "$(vm_host 10.21.2.11)" | sort | tr '\n' ' ' | sed 's/ $//')
info "sn-t21a : ${A_HOSTS} ; sn-t21b : ${B_HOSTS}"
check "probe sn-t21a : uniquement les couples MAC/IP de sn-t21a" test "$(dhcp_hosts vp-t21_br-t21a)" = "${A_HOSTS}"
check "probe sn-t21b : uniquement les couples MAC/IP de sn-t21b" test "$(dhcp_hosts vp-t21_br-t21b)" = "${B_HOSTS}"
NODE

View file

@ -1,48 +0,0 @@
# fonctionnalité: DHCP par dnsmasq (backend dnsmasq) — bail, server-id, renouvellement, option 121, une instance par subnet écoutant sur la gateway anycast
# hôtes: hv2
# tickets: #46, #57
on hv2 <<'NODE'
KEY=$(vm_key)
check "VPC vp-t22" vpc_create vp-t22 10.22.0.0/16
check "subnet sn-t22a" subnet_create sn-t22a vp-t22 2201 10.22.1.0/24
check "subnet sn-t22b" subnet_create sn-t22b vp-t22 2202 10.22.2.0/24
for s in a b; do
inst="vp-t22_br-t22${s}"
check "dnsmasq : unité dnsmasq@${inst} active" systemctl is-active --quiet "dnsmasq@${inst}.service"
check "dnsmasq : configuration ${inst}.conf présente" test -f "/etc/dnsmasq.d/${inst}.conf"
check "dnsmasq : sn-t22${s} écoute sur la gateway anycast gw-t22${s}" grep -qx "interface=gw-t22${s}" "/etc/dnsmasq.d/${inst}.conf"
check "dnsmasq : sn-t22${s} exclut le bridge br-t22${s}" grep -qx "except-interface=br-t22${s}" "/etc/dnsmasq.d/${inst}.conf"
check "dnsmasq : sn-t22${s}, aucune socket du serveur intégré" test ! -e "/run/two/dhcp/${inst}.sock"
done
check "VM t22-a1, démarrée seule" vm_create t22-a1 sn-t22a 10.22.1.10 "${KEY}"
check "VM t22-a1 joignable" vm_wait vp-t22 10.22.1.10
check "VM t22-b1, démarrée seule" vm_create t22-b1 sn-t22b 10.22.2.10 "${KEY}"
check "VM t22-b1 joignable" vm_wait vp-t22 10.22.2.10
vm_create t22-a2 sn-t22a 10.22.1.11 "${KEY}" > /tmp/t22-a2.log 2>&1 & A=$!
vm_create t22-b2 sn-t22b 10.22.2.11 "${KEY}" > /tmp/t22-b2.log 2>&1 & B=$!
wait "${A}"; RA=$?
wait "${B}"; RB=$?
check "VM t22-a2, démarrée en même temps que t22-b2" test "${RA}" -eq 0
check "VM t22-b2, démarrée en même temps que t22-a2" test "${RB}" -eq 0
for vm in 10.22.1.10:10.22.1.254 10.22.1.11:10.22.1.254 10.22.2.10:10.22.2.254 10.22.2.11:10.22.2.254; do
ip=${vm%%:*}; gw=${vm#*:}
check "${ip} joignable" vm_wait vp-t22 "${ip}"
check "${ip} : adresse de son propre subnet" has_addr vp-t22 "${ip}"
check "${ip} : bail DHCP tenu par systemd-networkd" vm_ssh vp-t22 "${ip}" 'ls /run/systemd/netif/leases/ | grep -q .'
check "${ip} : bail servi par la gateway ${gw} (server-id)" test "$(vm_lease vp-t22 "${ip}" SERVER_ADDRESS)" = "${gw}"
check "${ip} : route par défaut via ${gw}" route_via vp-t22 "${ip}" default "${gw}"
check "${ip} : route vers la VPC via ${gw}" route_via vp-t22 "${ip}" 10.22.0.0/16 "${gw}"
check "${ip} : route /32 vers les métadonnées via ${gw}" route_via vp-t22 "${ip}" 169.254.169.254 "${gw}"
done
check "10.22.1.10 : bail renouvelé (networkctl renew)" lease_renewed vp-t22 10.22.1.10
check "10.22.1.10 : même adresse après le renouvellement" has_addr vp-t22 10.22.1.10
check "10.22.1.10 : renouvellement servi par la gateway" test "$(vm_lease vp-t22 10.22.1.10 SERVER_ADDRESS)" = 10.22.1.254
vm_host () { echo "$(vm_ssh vp-t22 "${1}" 'cat /sys/class/net/ens3/address'),${1}"; }
reserved () { cat /etc/dnsmasq.d/"${1}".hosts.d/* | grep -hoiE '([0-9a-f]{2}:){5}[0-9a-f]{2},[0-9.]+' | tr 'A-F' 'a-f' | sort | tr '\n' ' ' | sed 's/ $//'; }
A_HOSTS=$(printf '%s\n' "$(vm_host 10.22.1.10)" "$(vm_host 10.22.1.11)" | sort | tr '\n' ' ' | sed 's/ $//')
B_HOSTS=$(printf '%s\n' "$(vm_host 10.22.2.10)" "$(vm_host 10.22.2.11)" | sort | tr '\n' ' ' | sed 's/ $//')
info "sn-t22a : ${A_HOSTS} ; sn-t22b : ${B_HOSTS}"
check "réservations dnsmasq de sn-t22a : uniquement les couples MAC/IP de sn-t22a" test "$(reserved vp-t22_br-t22a)" = "${A_HOSTS}"
check "réservations dnsmasq de sn-t22b : uniquement les couples MAC/IP de sn-t22b" test "$(reserved vp-t22_br-t22b)" = "${B_HOSTS}"
NODE

View file

@ -1,36 +0,0 @@
# fonctionnalité: serveur de métadonnées et cloud-init — sshkey, password (hash), user_data servi tel quel, documents absents (templates), VM sans compte
# hôtes: hv1
# tickets: #43, #46
on hv1 <<'NODE'
KEY=$(vm_key)
HASH=$(openssl passwd -6 -salt t23lab two-lab)
UD=$(printf '%s\n' '#cloud-config' 'runcmd:' " - [sh, -c, 'echo t23 > /var/tmp/t23-runcmd']")
UD64=$(printf '%s\n' "${UD}" | base64 -w0)
served () { cat "/run/two/metadata/${1}/${2}"; }
check "VPC vp-t23" vpc_create vp-t23 10.23.0.0/16
check "subnet sn-t23" subnet_create sn-t23 vp-t23 2301 10.23.1.0/24
check "VM t23-k : sshkey, password et user_data" vm_launch t23-k --nic sn-t23=10.23.1.10 --sshkey "${KEY}" --password "${HASH}" --user-data "${UD64}"
check "VM t23-s : sshkey seule (témoin)" vm_launch t23-s --nic sn-t23=10.23.1.11 --sshkey "${KEY}"
check "VM t23-n : ni sshkey ni password" vm_launch t23-n --nic sn-t23=10.23.1.12
check "t23-k joignable en SSH (sshkey servie)" vm_wait vp-t23 10.23.1.10
check "t23-k : meta-data, instance-id = nom de la VM" vm_grep vp-t23 10.23.1.10 'curl -fsS http://169.254.169.254/meta-data' '^instance-id: t23-k$'
check "t23-k : user-data servi tel quel" test "$(vm_meta vp-t23 10.23.1.10 user-data)" = "$(printf '%s' "${UD}")"
check "t23-k : runcmd du user_data exécuté" vm_grep vp-t23 10.23.1.10 'cat /var/tmp/t23-runcmd' '^t23$'
check "t23-k : vendor-data porte la clé SSH" vm_grep vp-t23 10.23.1.10 'curl -fsS http://169.254.169.254/vendor-data' "$(cut -d" " -f2 <<< "${KEY}")"
check "t23-k : hash du password posé sur le compte syonad" vm_ssh vp-t23 10.23.1.10 "sudo grep -qF 'syonad:${HASH}:' /etc/shadow"
check "t23-s joignable en SSH" vm_wait vp-t23 10.23.1.11
check "t23-s : user_data absent, user-data servi vide (template)" test -z "$(vm_meta vp-t23 10.23.1.11 user-data)"
check "t23-s : aucun runcmd exécuté" vm_fails vp-t23 10.23.1.11 'test -e /var/tmp/t23-runcmd'
check "t23-s : password absent, compte syonad verrouillé" vm_ssh vp-t23 10.23.1.11 "sudo grep -q '^syonad:!' /etc/shadow"
check "t23-s : vendor-data sans passwd" vm_fails vp-t23 10.23.1.11 'curl -fsS http://169.254.169.254/vendor-data | grep -qE "^ *passwd:"'
served_line () { served "${1}" "${2}" | grep -qx -- "${3}"; }
check "t23-n : serveur de métadonnées actif (metadata@t23-n)" systemctl is-active --quiet metadata@t23-n.service
check "t23-n : meta-data préparé (témoin)" served_line t23-n meta-data 'instance-id: t23-n'
check "t23-n : vendor-data vide, aucun compte à créer" test -z "$(served t23-n vendor-data)"
check "t23-n : user-data vide" test -z "$(served t23-n user-data)"
check "t23-n : démarrée, SSH refusé faute de compte (Permission denied)" ssh_denied vp-t23 10.23.1.12
NODE

View file

@ -1,21 +0,0 @@
# fonctionnalité: démarrage UEFI (OVMF) — firmware et variables par VM, VM démarrée en UEFI, témoin BIOS
# hôtes: hv1
# tickets: UEFI (sans ticket)
on hv1 <<'NODE'
KEY=$(vm_key)
check "prérequis : firmware OVMF /usr/share/OVMF/OVMF_CODE.fd présent" test -f /usr/share/OVMF/OVMF_CODE.fd
check "prérequis : modèle de variables /usr/share/OVMF/OVMF_VARS.fd présent" test -f /usr/share/OVMF/OVMF_VARS.fd
check "VPC vp-t24" vpc_create vp-t24 10.24.0.0/16
check "subnet sn-t24" subnet_create sn-t24 vp-t24 2401 10.24.1.0/24
check "VM t24-u en UEFI" vm_launch t24-u --nic sn-t24=10.24.1.10 --sshkey "${KEY}" --uefi
check "VM t24-b sans UEFI (témoin)" vm_launch t24-b --nic sn-t24=10.24.1.11 --sshkey "${KEY}"
check "t24-u : variables UEFI propres à la VM" test -f /run/two/vms/uefi/t24-u-uefi-vars.fd
check "t24-b : aucune variable UEFI" test ! -e /run/two/vms/uefi/t24-b-uefi-vars.fd
check "t24-u joignable" vm_wait vp-t24 10.24.1.10
check "t24-b joignable" vm_wait vp-t24 10.24.1.11
check "t24-u : démarrée en UEFI (/sys/firmware/efi)" vm_ssh vp-t24 10.24.1.10 'test -d /sys/firmware/efi'
check "t24-b : démarrée en BIOS, pas de /sys/firmware/efi" vm_fails vp-t24 10.24.1.11 'test -d /sys/firmware/efi'
check "suppression de t24-u" vm_delete t24-u
check "t24-u supprimée : variables UEFI retirées" test ! -e /run/two/vms/uefi/t24-u-uefi-vars.fd
NODE

View file

@ -1,26 +0,0 @@
# fonctionnalité: VM à plusieurs interfaces — une NIC par subnet, adresses posées, route par défaut sur la primaire seule
# hôtes: hv1
# tickets: #33, #62
on hv1 <<'NODE'
KEY=$(vm_key)
check "VPC vp-t25" vpc_create vp-t25 10.25.0.0/16
check "subnet sn-t25a" subnet_create sn-t25a vp-t25 2501 10.25.1.0/24
check "subnet sn-t25b" subnet_create sn-t25b vp-t25 2502 10.25.2.0/24
check "VM t25-m : primaire sur sn-t25a, seconde NIC sur sn-t25b (rangs différents, MAC distinctes)" vm_launch t25-m --nic sn-t25a=10.25.1.10 --nic sn-t25b=10.25.2.20 --sshkey "${KEY}"
check "API : deux interfaces, une seule primaire" test "$(curl -fsS "${API}/vms/t25-m" | jq -c '[.interfaces[] | .primary]')" = '[true,false]'
check "t25-m joignable sur sa primaire 10.25.1.10" vm_wait vp-t25 10.25.1.10
check "t25-m : deux interfaces réseau (ens3, ens4)" vm_ssh vp-t25 10.25.1.10 'test -e /sys/class/net/ens3 && test -e /sys/class/net/ens4'
check "t25-m : 10.25.1.10 sur ens3" vm_grep vp-t25 10.25.1.10 'ip -4 -o addr show dev ens3' ' 10.25.1.10/'
known "#73" "t25-m : ens4 obtient un bail DHCP de systemd-networkd" test "$(vm_lease vp-t25 10.25.1.10 ADDRESS ens4)" = 10.25.2.20
known "#73" "t25-m : 10.25.2.20 sur ens4" vm_grep vp-t25 10.25.1.10 'ip -4 -o addr show dev ens4' ' 10.25.2.20/'
known "#73" "t25-m joignable sur sa seconde adresse 10.25.2.20" vm_wait vp-t25 10.25.2.20
check "t25-m : une seule route par défaut" test "$(vm_ssh vp-t25 10.25.1.10 'ip -4 route show default' | wc -l)" -eq 1
check "t25-m : route par défaut via la gateway de la primaire 10.25.1.254" route_via vp-t25 10.25.1.10 default 10.25.1.254
known "#73" "t25-m : bail de ens4 servi par la gateway de sn-t25b" test "$(vm_lease vp-t25 10.25.1.10 SERVER_ADDRESS ens4)" = 10.25.2.254
check "t25-m : route /32 des métadonnées présente" vm_grep vp-t25 10.25.1.10 'ip -4 route show 169.254.169.254' 'via 10.25.'
nic_macs () { ps -eo args | grep "[q]emu.*${1}" | grep -oE 'mac=[0-9A-Fa-f:]+' | sort | uniq | wc -l; }
check "t25-m : deux MAC distinctes sur la ligne QEMU (témoin)" test "$(nic_macs t25-m)" -eq 2
check "VM t25-r : deux NIC de même rang (10.25.1.30, 10.25.2.30)" vm_launch t25-r --nic sn-t25a=10.25.1.30 --nic sn-t25b=10.25.2.30 --sshkey "${KEY}"
known "#62" "t25-r : deux NIC de même rang reçoivent des MAC distinctes" test "$(nic_macs t25-r)" -eq 2
NODE

View file

@ -1,27 +0,0 @@
# fonctionnalité: VM à plusieurs disques — virtio (vdX) et SCSI (sdX), tailles et bus vus par la VM, démarrage sur vda
# hôtes: hv1
# tickets: #32
on hv1 <<'NODE'
KEY=$(vm_key)
mkdir -p "${VOLUMES}"
check "volume t26-d-sdb 1 Gio" qemu-img create -q -f qcow2 "${VOLUMES}/t26-d-sdb.qcow2" 1G
check "volume t26-d-sda 2 Gio" qemu-img create -q -f qcow2 "${VOLUMES}/t26-d-sda.qcow2" 2G
check "VPC vp-t26" vpc_create vp-t26 10.26.0.0/16
check "subnet sn-t26" subnet_create sn-t26 vp-t26 2601 10.26.1.0/24
check "VM t26-d : vda (système), sdb, sda" vm_launch t26-d --nic sn-t26=10.26.1.10 --sshkey "${KEY}" \
--disk "sdb=${VOLUMES}/t26-d-sdb.qcow2" --disk "sda=${VOLUMES}/t26-d-sda.qcow2"
check "API : trois disques" test "$(curl -fsS "${API}/vms/t26-d" | jq -r '[.storage[].dev] | sort | join(" ")')" = "sda sdb vda"
check "t26-d joignable (démarrée sur vda)" vm_wait vp-t26 10.26.1.10
check "t26-d : racine sur vda" vm_grep vp-t26 10.26.1.10 'findmnt -n -o SOURCE /' '^/dev/vda'
size_is () { local v; v=$(vm_ssh vp-t26 10.26.1.10 "lsblk -b -dn -o SIZE /dev/${1}" 2>&1 | tr -d ' '); [ "${v}" = "${2}" ] || { echo "lu : ${v}"; return 1; }; }
target_size () { local v; v=$(vm_ssh vp-t26 10.26.1.10 "lsblk -b -dn -o HCTL,SIZE" 2>&1 | awk -v t="${1}" '{split($1, h, ":")} h[3] == t {print $2}'); [ "${v}" = "${2}" ] || { echo "lu : ${v:-aucun disque sur la cible ${1}}"; return 1; }; }
check "t26-d : sda déclaré → cible SCSI 0, 2 Gio" target_size 0 2147483648
check "t26-d : sdb déclaré → cible SCSI 1, 1 Gio" target_size 1 1073741824
known_flaky "#74" "t26-d : nom dans l'invité = dev déclaré, sdb de 1 Gio" size_is sdb 1073741824
known_flaky "#74" "t26-d : nom dans l'invité = dev déclaré, sda de 2 Gio" size_is sda 2147483648
check "t26-d : sdb en SCSI" vm_grep vp-t26 10.26.1.10 'readlink -f /sys/block/sdb/device/driver' 'sd$'
check "t26-d : sda en SCSI (virtio-scsi)" vm_ssh vp-t26 10.26.1.10 'test -d /sys/block/sda/device/scsi_device && readlink -f /sys/block/sda | grep -q virtio'
check "t26-d : vda n'est pas en SCSI (témoin)" vm_fails vp-t26 10.26.1.10 'test -d /sys/block/vda/device/scsi_device'
check "t26-d : écriture sur sdb et sda" vm_ssh vp-t26 10.26.1.10 'sudo dd if=/dev/zero of=/dev/sdb bs=1M count=8 oflag=direct status=none && sudo dd if=/dev/zero of=/dev/sda bs=1M count=8 oflag=direct status=none'
NODE

View file

@ -1,25 +0,0 @@
# fonctionnalité: redémarrage d'une VM depuis l'invité — même processus QEMU, même adresse, nouveau bail, user_data non rejoué
# hôtes: hv1
# tickets: #46
on hv1 <<'NODE'
KEY=$(vm_key)
UD64=$(printf '%s\n' '#cloud-config' 'runcmd:' " - [sh, -c, 'date +%s%N >> /var/tmp/t27-runcmd']" | base64 -w0)
check "VPC vp-t27" vpc_create vp-t27 10.27.0.0/16
check "subnet sn-t27" subnet_create sn-t27 vp-t27 2701 10.27.1.0/24
check "VM t27-r, user_data qui écrit une ligne par exécution" vm_launch t27-r --nic sn-t27=10.27.1.10 --sshkey "${KEY}" --user-data "${UD64}"
check "t27-r joignable" vm_wait vp-t27 10.27.1.10
check "t27-r : runcmd exécuté une fois au premier démarrage" test "$(vm_ssh vp-t27 10.27.1.10 'wc -l < /var/tmp/t27-runcmd')" -eq 1
BOOT=$(vm_boot_id vp-t27 10.27.1.10)
QEMU=$(pgrep -f "${VOLUMES}/t27-r.qcow2" | sort | tr '\n' ' ')
info "boot_id ${BOOT:-illisible} ; processus QEMU ${QEMU:-introuvable}"
check "prérequis : boot_id et processus QEMU relevés" test -n "${BOOT}" -a -n "${QEMU}"
check "t27-r : redémarrage demandé depuis l'invité" vm_ssh vp-t27 10.27.1.10 'sudo systemd-run --on-active=2 systemctl reboot'
check "t27-r : redémarrée (boot_id changé) et de nouveau joignable" wait_reboot vp-t27 10.27.1.10 "${BOOT}"
check "t27-r : toujours running pour l'API" test "$(api_state vms/t27-r)" = running
check "t27-r : même processus QEMU (redémarrage invité, pas de recréation)" test "$(pgrep -f "${VOLUMES}/t27-r.qcow2" | sort | tr '\n' ' ')" = "${QEMU}"
check "t27-r : même adresse 10.27.1.10" has_addr vp-t27 10.27.1.10
check "t27-r : nouveau bail obtenu après le démarrage" vm_ssh vp-t27 10.27.1.10 'f=/run/systemd/netif/leases/$(cat /sys/class/net/ens3/ifindex); sudo test -f "$f" && [ "$(sudo stat -c %Y "$f")" -ge "$(( $(date +%s) - $(cut -d. -f1 /proc/uptime) ))" ]'
check "t27-r : bail servi par la gateway" test "$(vm_lease vp-t27 10.27.1.10 SERVER_ADDRESS)" = 10.27.1.254
check "t27-r : user_data non rejoué (même instance-id, une seule ligne)" test "$(vm_ssh vp-t27 10.27.1.10 'wc -l < /var/tmp/t27-runcmd')" -eq 1
NODE

View file

@ -1,51 +0,0 @@
# fonctionnalité: gateway d'un subnet vxlan — gateway anycast et adresse d'émission calculées, default_route et gateway explicite, routes DHCP, macvlan gw-, FDB locale, sysctls ARP, règles de confinement, suppression et recréation
# hôtes: hv1
# tickets: #57, #43
on hv1 <<'NODE'
KEY=$(vm_key)
MAC=$(anycast_mac 3101)
check "VPC vp-t31" vpc_create vp-t31 10.31.0.0/16
check "subnet sn-t31a, default_route absent" subnet_create sn-t31a vp-t31 3101 10.31.1.0/24
check "subnet sn-t31b, default_route et gateway 10.31.2.1" subnet_create sn-t31b vp-t31 3102 10.31.2.0/24 ',"default_route":true,"gateway":"10.31.2.1"'
check "sn-t31a : gateway calculée 10.31.1.254 et adresse d'émission 10.31.1.253 (GET)" sh -c "curl -fsS ${API}/subnets/sn-t31a | jq -e '.interface_ip == \"10.31.1.254\" and .relay_ip == \"10.31.1.253\"'"
check "sn-t31a : macvlan gw-t31a, MAC anycast ${MAC}" sh -c "ip -n vp-t31 -o link show gw-t31a | grep -qi 'link/ether ${MAC} '"
check "sn-t31a : gateway 10.31.1.254/32 sur gw-t31a" sh -c "ip -n vp-t31 -4 -o addr show dev gw-t31a | grep -q ' 10.31.1.254/32 '"
check "sn-t31a : adresse d'émission 10.31.1.253/32 sur br-t31a" sh -c "ip -n vp-t31 -4 -o addr show dev br-t31a | grep -q ' 10.31.1.253/32 '"
check "sn-t31a : la gateway n'est pas sur br-t31a" sh -c "! ip -n vp-t31 -4 -o addr show dev br-t31a | grep -q ' 10.31.1.254/'"
check "sn-t31a : MAC anycast en entrée FDB locale permanente de br-t31a" sh -c 'ip netns exec vp-t31 bridge fdb show br br-t31a | grep -qi "^$1 dev br-t31a master br-t31a permanent"' _ "${MAC}"
check "sn-t31a : route du subnet émise depuis la gateway" sh -c "ip -n vp-t31 -4 route show 10.31.1.0/24 | grep -q 'src 10.31.1.254'"
for dev in br-t31a gw-t31a; do
check "sn-t31a : ${dev}, arp_ignore=1 et arp_announce=2" sh -c "[ \"\$(ip netns exec vp-t31 sysctl -n net.ipv4.conf.${dev}.arp_ignore) \$(ip netns exec vp-t31 sysctl -n net.ipv4.conf.${dev}.arp_announce)\" = '1 2' ]"
done
check "sn-t31a : confinement de la MAC anycast sur v-t31a-i (nat PREROUTING, FORWARD, OUTPUT)" test "$(ebt_confined vp-t31 v-t31a-i "${MAC}")" -eq 3
for ip in 10.31.1.254 10.31.1.253; do
check "sn-t31a : requêtes ARP vers ${ip} bloquées en sortie de v-t31a-i" ebt_arp_drop vp-t31 v-t31a-i "${ip}"
check "sn-t31a : DHCP émis depuis ${ip} bloqué en sortie de v-t31a-i" ebt_dhcp_drop vp-t31 v-t31a-i "${ip}"
done
check "VM t31-a" vm_create t31-a sn-t31a 10.31.1.10 "${KEY}"
check "VM t31-b" vm_create t31-b sn-t31b 10.31.2.10 "${KEY}"
check "t31-a joignable" vm_wait vp-t31 10.31.1.10
check "t31-b joignable" vm_wait vp-t31 10.31.2.10
check "sn-t31a : route par défaut via la gateway 10.31.1.254" route_via vp-t31 10.31.1.10 default 10.31.1.254
check "sn-t31a : route vers la VPC via la gateway" route_via vp-t31 10.31.1.10 10.31.0.0/16 10.31.1.254
check "sn-t31a : route /32 vers les métadonnées via la gateway" route_via vp-t31 10.31.1.10 169.254.169.254 10.31.1.254
check "sn-t31b : route par défaut via la gateway explicite 10.31.2.1" route_via vp-t31 10.31.2.10 default 10.31.2.1
check "sn-t31b : route vers la VPC via la gateway du subnet, pas via la gateway explicite" route_via vp-t31 10.31.2.10 10.31.0.0/16 10.31.2.254
check "sn-t31b : route /32 vers les métadonnées via la gateway du subnet" route_via vp-t31 10.31.2.10 169.254.169.254 10.31.2.254
check "t31-a résout sa gateway vers la MAC anycast ${MAC}" vm_grep vp-t31 10.31.1.10 'ping -n -c 1 -W 2 10.31.1.254 >/dev/null; ip neigh show 10.31.1.254' "lladdr ${MAC} "
check "le netns émet vers t31-a depuis la gateway 10.31.1.254" sh -c "ip -n vp-t31 -4 route get 10.31.1.10 | grep -q 'src 10.31.1.254 '"
check "suppression de t31-a" vm_delete t31-a
check "suppression de sn-t31a" api_delete subnets/sn-t31a
check "sn-t31a supprimé" wait_state subnets/sn-t31a deleted
check "sn-t31a : plus de macvlan gw-t31a dans le netns" sh -c "! ip -n vp-t31 link show gw-t31a >/dev/null 2>&1"
check "sn-t31a : plus aucune règle ebtables pour v-t31a-i" test -z "$(ebt_rules vp-t31 v-t31a-i)"
check "sn-t31b : règles de son propre subnet toujours présentes (témoin)" test -n "$(ebt_rules vp-t31 v-t31b-i)"
check "sn-t31a recréé" subnet_create sn-t31a vp-t31 3101 10.31.1.0/24
check "VM t31-a2 sur le subnet recréé" vm_create t31-a2 sn-t31a 10.31.1.11 "${KEY}"
check "t31-a2 joignable" vm_wait vp-t31 10.31.1.11
check "après recréation : route par défaut via la gateway 10.31.1.254" route_via vp-t31 10.31.1.11 default 10.31.1.254
check "après recréation : route vers la VPC via la gateway" route_via vp-t31 10.31.1.11 10.31.0.0/16 10.31.1.254
check "après recréation : route /32 vers les métadonnées" route_via vp-t31 10.31.1.11 169.254.169.254 10.31.1.254
check "après recréation : MAC anycast en FDB locale de br-t31a" sh -c 'ip netns exec vp-t31 bridge fdb show br br-t31a | grep -qi "^$1 dev br-t31a master br-t31a permanent"' _ "${MAC}"
NODE

View file

@ -1,28 +0,0 @@
# fonctionnalité: routage entre deux subnets vxlan d'une même VPC sur un même hôte, sans et avec l3vni — ICMP, TCP, saut unique par la gateway
# hôtes: hv1
# tickets: #57, #41
on hv1 <<'NODE'
KEY=$(vm_key)
check "VPC vp-t32n, sans l3vni" vpc_create vp-t32n 10.32.0.0/18
check "subnet sn-t32a (VNI 3201)" subnet_create sn-t32a vp-t32n 3201 10.32.1.0/24
check "subnet sn-t32b (VNI 3202)" subnet_create sn-t32b vp-t32n 3202 10.32.2.0/24
check "VPC vp-t32r, l3vni 3200" vpc_create vp-t32r 10.32.64.0/18 3200
check "subnet sn-t32c (VNI 3211)" subnet_create sn-t32c vp-t32r 3211 10.32.65.0/24
check "subnet sn-t32d (VNI 3212)" subnet_create sn-t32d vp-t32r 3212 10.32.66.0/24
check "VM t32-a" vm_create t32-a sn-t32a 10.32.1.10 "${KEY}"
check "VM t32-b" vm_create t32-b sn-t32b 10.32.2.10 "${KEY}"
check "VM t32-c" vm_create t32-c sn-t32c 10.32.65.10 "${KEY}"
check "VM t32-d" vm_create t32-d sn-t32d 10.32.66.10 "${KEY}"
for pair in vp-t32n:10.32.1.10:10.32.2.10:10.32.1.254:"sans l3vni" vp-t32r:10.32.65.10:10.32.66.10:10.32.65.254:"avec l3vni"; do
IFS=: read -r vpc src dst gw label <<<"${pair}"
check "${label} : ${src} joignable" vm_wait "${vpc}" "${src}"
check "${label} : ${dst} joignable (témoin : la cible est vivante)" vm_wait "${vpc}" "${dst}"
check "${label} : ${src} joint ${dst}, autre subnet, même hôte (ICMP)" vm_ssh "${vpc}" "${src}" "ping -n -c 3 -W 2 ${dst}"
check "${label} : ${src} ouvre une connexion TCP vers ${dst}:22" vm_ssh "${vpc}" "${src}" "timeout 5 bash -c '</dev/tcp/${dst}/22'"
check "${label} : ${dst} joint ${src} (retour)" vm_ssh "${vpc}" "${dst}" "ping -n -c 3 -W 2 ${src}"
check "${label} : TTL 1 expire à la gateway ${gw}" vm_grep "${vpc}" "${src}" "ping -n -c 3 -i 1.2 -W 2 -t 1 ${dst}" "From ${gw} .*exceeded"
check "${label} : TTL 2 atteint ${dst}, un seul saut" vm_ssh "${vpc}" "${src}" "ping -n -c 1 -W 2 -t 2 ${dst}"
done
check "avec l3vni : le /24 local de sn-t32d ne passe pas par la VRF (route connectée dans le netns)" sh -c "ip -n vp-t32r -4 route show 10.32.66.0/24 | grep -q 'dev br-t32d'"
NODE

View file

@ -1,68 +0,0 @@
# fonctionnalité: subnet en mode bridge rattaché au bridge br-lan de l'hôte — un hôte, puis le même subnet sur deux hôtes (une seule réponse ARP pour interface_ip, métadonnées servies par l'hôte de la VM)
# hôtes: hv1 hv2
# tickets: #70
on hv1 <<'NODE'
KEY=$(vm_key)
check "prérequis : br-lan présent sur hv1, avec l'adresse de l'hôte 10.33.0.11" sh -c "ip -4 -o addr show dev br-lan | grep -q ' 10.33.0.11/24 '"
check "prérequis : l'interface du segment lan est un port de br-lan, sans adresse" sh -c "ip -o link show lan | grep -q 'master br-lan' && [ -z \"\$(ip -4 -o addr show dev lan)\" ]"
check "VPC vp-t33" vpc_create vp-t33 10.33.0.0/16
check "subnet sn-t33a en mode bridge sur br-lan (iface_type lan, interface_ip 10.33.0.1)" subnet_create_bridge sn-t33a vp-t33 10.33.0.0/24 10.33.0.1
check "sn-t33a : mode bridge et interface_ip lus dans le GET" sh -c "curl -fsS ${API}/subnets/sn-t33a | jq -e '.mode == \"bridge\" and .interface_ip == \"10.33.0.1\"'"
check "sn-t33a : v-t33a-e rattaché à br-lan" sh -c "ip -o link show v-t33a-e | grep -q 'master br-lan'"
check "sn-t33a : aucun VXLAN pour ce subnet" sh -c "! ip -o link show | grep -q 'vxlan.*master br-t33a'"
check "sn-t33a : interface_ip 10.33.0.1 sur br-t33a dans le netns" sh -c "ip -n vp-t33 -4 -o addr show dev br-t33a | grep -q ' 10.33.0.1/'"
check "sn-t33a : pas de gateway anycast en mode bridge (pas de gw-t33a)" sh -c "! ip -n vp-t33 link show gw-t33a >/dev/null 2>&1"
check "VM t33-a1 10.33.0.21" vm_launch t33-a1 --nic sn-t33a=10.33.0.21 --sshkey "${KEY}"
check "VM t33-a2 10.33.0.22" vm_launch t33-a2 --nic sn-t33a=10.33.0.22 --sshkey "${KEY}"
for ip in 10.33.0.21 10.33.0.22; do
check "${ip} joignable" vm_wait vp-t33 "${ip}"
check "${ip} : adresse posée" has_addr vp-t33 "${ip}"
check "${ip} : bail servi par interface_ip 10.33.0.1 (server-id)" test "$(vm_lease vp-t33 "${ip}" SERVER_ADDRESS)" = 10.33.0.1
check "${ip} : route par défaut via 10.33.0.1" route_via vp-t33 "${ip}" default 10.33.0.1
check "${ip} : route /32 vers les métadonnées via 10.33.0.1" route_via vp-t33 "${ip}" 169.254.169.254 10.33.0.1
check "${ip} : pas de route vers la VPC 10.33.0.0/16 (option 121 sans route du VPC en bridge)" sh -c "[ -z \"\$1\" ]" _ "$(vm_ssh vp-t33 "${ip}" 'ip -4 route show 10.33.0.0/16')"
done
check "t33-a1 : métadonnées de t33-a1 (instance-id)" vm_grep vp-t33 10.33.0.21 'curl -fsS http://169.254.169.254/meta-data' '^instance-id: t33-a1$'
check "t33-a1 joint t33-a2, même hôte" vm_ssh vp-t33 10.33.0.21 'ping -n -c 3 -W 2 10.33.0.22'
check "hv1 joint t33-a1 depuis br-lan, hors netns" ping -c 2 -W 2 10.33.0.21
check "une seule réponse ARP pour 10.33.0.1 avec un seul hôte (témoin)" test "$(vm_frames vp-t33 10.33.0.21 arp-who ens3 10.33.0.21 10.33.0.1 2 | grep -c .)" -eq 1
NODE
on hv2 <<'NODE'
KEY=$(vm_key)
check "prérequis : br-lan présent sur hv2, avec l'adresse de l'hôte 10.33.0.12" sh -c "ip -4 -o addr show dev br-lan | grep -q ' 10.33.0.12/24 '"
check "hv2 : VPC vp-t33" vpc_create vp-t33 10.33.0.0/16
check "hv2 : même subnet sn-t33a en mode bridge" subnet_create_bridge sn-t33a vp-t33 10.33.0.0/24 10.33.0.1
check "hv2 : VM t33-b1 10.33.0.23" vm_launch t33-b1 --nic sn-t33a=10.33.0.23 --sshkey "${KEY}"
check "hv2 : 10.33.0.23 joignable" vm_wait vp-t33 10.33.0.23
NODE
on hv1 <<'NODE'
own_meta () {
local n ok=0
for n in 1 2 3 4 5; do
vm_ssh vp-t33 "${1}" 'sudo ip neigh flush dev ens3' >/dev/null 2>&1
vm_grep vp-t33 "${1}" 'curl -fsS -m 3 http://169.254.169.254/meta-data' "^instance-id: ${2}\$" && ok=$((ok + 1))
done
[ "${ok}" -eq 5 ] || { echo "${2} : ${ok}/5 réponses avec ses propres métadonnées"; return 1; }
}
RESPONDERS=$(vm_frames vp-t33 10.33.0.21 arp-who ens3 10.33.0.21 10.33.0.1 2)
info "MAC qui répondent pour 10.33.0.1 vues de t33-a1 : $(echo ${RESPONDERS})"
known "#75" "deux hôtes : t33-a1 (hv1) joint t33-b1 (hv2) sur le segment lan" vm_ssh vp-t33 10.33.0.21 'ping -n -c 3 -W 2 10.33.0.23'
known "#75" "deux hôtes : une seule MAC répond pour interface_ip 10.33.0.1" test "$(grep -c . <<<"${RESPONDERS}")" -eq 1
known_flaky "#75" "deux hôtes : t33-a1 reçoit toujours ses propres métadonnées (5 essais, cache ARP vidé)" own_meta 10.33.0.21 t33-a1
NODE
on hv2 <<'NODE'
own_meta () {
local n ok=0
for n in 1 2 3 4 5; do
vm_ssh vp-t33 "${1}" 'sudo ip neigh flush dev ens3' >/dev/null 2>&1
vm_grep vp-t33 "${1}" 'curl -fsS -m 3 http://169.254.169.254/meta-data' "^instance-id: ${2}\$" && ok=$((ok + 1))
done
[ "${ok}" -eq 5 ] || { echo "${2} : ${ok}/5 réponses avec ses propres métadonnées"; return 1; }
}
known_flaky "#75" "deux hôtes : t33-b1 (hv2) reçoit toujours ses propres métadonnées (5 essais, cache ARP vidé)" own_meta 10.33.0.23 t33-b1
check "deux hôtes : t33-b1 (hv2) joint t33-a2 (hv1)" vm_ssh vp-t33 10.33.0.23 'ping -n -c 3 -W 2 10.33.0.22'
NODE

View file

@ -1,19 +0,0 @@
# fonctionnalité: isolation entre deux VPC sur un même hôte — ni ICMP ni TCP d'une VPC à l'autre
# hôtes: hv1
# tickets: #50
on hv1 <<'NODE'
KEY=$(vm_key)
check "VPC vp-t34a" vpc_create vp-t34a 10.34.0.0/17
check "VPC vp-t34b" vpc_create vp-t34b 10.34.128.0/17
check "subnet sn-t34a" subnet_create sn-t34a vp-t34a 3401 10.34.1.0/24
check "subnet sn-t34b" subnet_create sn-t34b vp-t34b 3402 10.34.129.0/24
check "VM t34-x dans vp-t34a" vm_create t34-x sn-t34a 10.34.1.10 "${KEY}"
check "VM t34-y dans vp-t34b" vm_create t34-y sn-t34b 10.34.129.10 "${KEY}"
check "t34-x joignable depuis sa VPC" vm_wait vp-t34a 10.34.1.10
check "t34-y joignable depuis sa VPC (témoin : la cible est vivante)" vm_wait vp-t34b 10.34.129.10
check "t34-x joint sa passerelle (témoin)" vm_ssh vp-t34a 10.34.1.10 'ping -c 2 -W 2 10.34.1.254'
check "t34-x ne joint pas t34-y en ICMP" vm_fails vp-t34a 10.34.1.10 'ping -c 2 -W 2 10.34.129.10'
check "t34-x n'ouvre pas de connexion TCP vers t34-y:22" vm_fails vp-t34a 10.34.1.10 'timeout 5 bash -c "</dev/tcp/10.34.129.10/22"'
check "t34-y ne joint pas t34-x en ICMP" vm_fails vp-t34b 10.34.129.10 'ping -c 2 -W 2 10.34.1.10'
NODE

View file

@ -1,87 +0,0 @@
# fonctionnalité: filtrage au port — en sortie vers le fabric (v-<id>-i) : ARP vers la gateway et l'adresse d'émission, DHCP émis depuis ces adresses, MAC anycast confinée dans les deux sens ; entre VM d'un même hôte : faux serveur DHCP et usurpation ARP de la gateway (comportement attendu, non filtré à ce jour)
# hôtes: hv1
# tickets: #57
on hv1 <<'NODE'
KEY=$(vm_key)
MAC=$(anycast_mac 3501)
FAB=v-t35a-e
S=/tmp/t35
check "VPC vp-t35" vpc_create vp-t35 10.35.0.0/16
check "subnet sn-t35a (VNI 3501)" subnet_create sn-t35a vp-t35 3501 10.35.1.0/24
check "VM t35-a" vm_create t35-a sn-t35a 10.35.1.10 "${KEY}"
check "VM t35-b" vm_create t35-b sn-t35a 10.35.1.11 "${KEY}"
check "t35-a joignable" vm_wait vp-t35 10.35.1.10
check "t35-b joignable" vm_wait vp-t35 10.35.1.11
check "python3 présent dans la VM (prérequis des trames brutes)" vm_ssh vp-t35 10.35.1.10 'command -v python3'
seen_on_fabric () {
local out="${1}" kind="${2}"
shift 2
sniff_start "${out}" "${FAB}" 6 "${kind}" "${@:1:$(( $# - 1 ))}"
vm_frames vp-t35 10.35.1.10 ${!#} >/dev/null 2>&1
wait
cat "${out}"
}
for ip in 10.35.1.254 10.35.1.253; do
n=$(seen_on_fabric "${S}.arp" arp-req "${ip}" "arp ens3 10.35.1.10 ${ip} 5")
check "requête ARP de t35-a vers ${ip} : aucune ne sort vers le fabric (${n} vue(s))" test "${n}" -eq 0
done
n=$(seen_on_fabric "${S}.arp" arp-req 10.35.1.200 "arp ens3 10.35.1.10 10.35.1.200 5")
check "requête ARP de t35-a vers 10.35.1.200 : sort vers le fabric (témoin, ${n} vue(s))" test "${n}" -gt 0
for ip in 10.35.1.254 10.35.1.253; do
n=$(seen_on_fabric "${S}.dhcp" udp-from "${ip}" 67 "dhcp ens3 ${ip} 68 5")
check "réponse DHCP émise par t35-a depuis ${ip} : aucune ne sort vers le fabric (${n} vue(s))" test "${n}" -eq 0
done
n=$(seen_on_fabric "${S}.dhcp" udp-from 10.35.1.10 67 "dhcp ens3 10.35.1.10 68 5")
check "réponse DHCP émise par t35-a depuis sa propre adresse : sort vers le fabric (témoin, ${n} vue(s))" test "${n}" -gt 0
n=$(seen_on_fabric "${S}.mac" marker t35-anycast "marker ens3 ${MAC} t35-anycast 5")
check "trame de t35-a avec la MAC anycast ${MAC} en source : aucune ne sort vers le fabric (${n} vue(s))" test "${n}" -eq 0
n=$(seen_on_fabric "${S}.mac" marker t35-autre "marker ens3 02:35:00:00:00:01 t35-autre 5")
check "trame de t35-a avec une autre MAC source : sort vers le fabric (témoin, ${n} vue(s))" test "${n}" -gt 0
vm_sniff_start "${S}.in" vp-t35 10.35.1.11 ens3 8 marker t35-entrant
frames marker "${FAB}" "${MAC}" t35-entrant 5
wait
check "trame venue du fabric avec la MAC anycast en source : bloquée avant le bridge ($(cat "${S}.in") vue(s) par t35-b)" test "$(cat "${S}.in")" = 0
vm_sniff_start "${S}.in" vp-t35 10.35.1.11 ens3 8 marker t35-temoin
frames marker "${FAB}" 02:35:00:00:00:02 t35-temoin 5
wait
check "trame venue du fabric avec une autre MAC source : reçue par t35-b (témoin, $(cat "${S}.in") vue(s))" test "$(cat "${S}.in")" -gt 0
BRMAC=$(ip -n vp-t35 -o link show br-t35a | grep -o 'link/ether [0-9a-f:]*' | cut -d' ' -f2)
sniff_start "${S}.gw" "${FAB}" 10 src-mac "${MAC}"
sniff_start "${S}.br" "${FAB}" 10 src-mac "${BRMAC}"
vm_ssh vp-t35 10.35.1.10 'ping -n -c 5 -i 0.5 -W 1 10.35.1.254' >/dev/null 2>&1
ip netns exec vp-t35 ping -n -c 3 -W 1 10.35.1.11 >/dev/null 2>&1
ip netns exec vp-t35 ping -n -c 3 -W 1 10.35.1.200 >/dev/null 2>&1
wait
check "trafic de la gateway (ping des VM, réponses du netns) : aucune trame avec la MAC anycast sur le fabric ($(cat "${S}.gw") vue(s))" test "$(cat "${S}.gw")" -eq 0
check "trafic du netns vers une adresse inconnue : ARP du bridge ${BRMAC} sur le fabric (témoin, $(cat "${S}.br") vue(s))" test "$(cat "${S}.br")" -gt 0
UNF="aucun filtrage entre VM d'un même hôte à ce jour"
vm_sniff_start "${S}.rogue" vp-t35 10.35.1.11 ens3 8 udp-from 10.35.1.10 67
vm_frames vp-t35 10.35.1.10 dhcp ens3 10.35.1.10 68 5 >/dev/null 2>&1
wait
known "#76" "faux serveur DHCP dans t35-a (67 → 68) : n'atteint pas t35-b, même subnet, même hôte (${UNF} ; $(cat "${S}.rogue") vue(s))" test "$(cat "${S}.rogue")" = 0
vm_sniff_start "${S}.rogue" vp-t35 10.35.1.11 ens3 8 udp-from 10.35.1.10 67
vm_frames vp-t35 10.35.1.10 dhcp ens3 10.35.1.10 6868 5 >/dev/null 2>&1
wait
check "même envoi de t35-a vers le port 6868 : reçu par t35-b (témoin, $(cat "${S}.rogue") vue(s))" test "$(cat "${S}.rogue")" -gt 0
AMAC=$(vm_ssh vp-t35 10.35.1.10 'cat /sys/class/net/ens3/address')
vm_ssh vp-t35 10.35.1.11 'ping -n -c 2 -W 1 10.35.1.254; ping -n -c 2 -W 1 10.35.1.253' >/dev/null 2>&1
RELAY_MAC=$(vm_neigh_mac vp-t35 10.35.1.11 10.35.1.253)
check "prérequis : t35-b résout la gateway vers la MAC anycast ${MAC}" test "$(vm_neigh_mac vp-t35 10.35.1.11 10.35.1.254)" = "${MAC}"
check "prérequis : t35-b résout l'adresse d'émission 10.35.1.253 (${RELAY_MAC:-non résolue})" test -n "${RELAY_MAC}"
vm_frames vp-t35 10.35.1.10 garp ens3 10.35.1.254 5 >/dev/null 2>&1
known "#76" "usurpation ARP de la gateway 10.35.1.254 par t35-a : t35-b garde la MAC anycast (${UNF} ; lue : $(vm_neigh_mac vp-t35 10.35.1.11 10.35.1.254))" test "$(vm_neigh_mac vp-t35 10.35.1.11 10.35.1.254)" = "${MAC}"
vm_frames vp-t35 10.35.1.10 garp ens3 10.35.1.253 5 >/dev/null 2>&1
known "#76" "usurpation ARP de l'adresse d'émission 10.35.1.253 par t35-a : t35-b garde ${RELAY_MAC:-?} (${UNF} ; lue : $(vm_neigh_mac vp-t35 10.35.1.11 10.35.1.253))" test "$(vm_neigh_mac vp-t35 10.35.1.11 10.35.1.253)" = "${RELAY_MAC}"
vm_ssh vp-t35 10.35.1.11 'sudo ip neigh replace 10.35.1.200 lladdr 02:35:00:00:00:99 dev ens3 nud stale' >/dev/null 2>&1
vm_frames vp-t35 10.35.1.10 garp ens3 10.35.1.200 5 >/dev/null 2>&1
check "usurpation ARP de 10.35.1.200 (adresse non protégée) par t35-a : t35-b l'associe à ${AMAC} (témoin, lue : $(vm_neigh_mac vp-t35 10.35.1.11 10.35.1.200))" test "$(vm_neigh_mac vp-t35 10.35.1.11 10.35.1.200)" = "${AMAC}"
rm -f "${S}".*
NODE

View file

@ -1,42 +0,0 @@
# fonctionnalité: subnet vxlan étendu entre deux hôtes par EVPN — VTEP local, VTEP distant et inondation appris, MAC des VM en type 2, trafic ICMP et TCP, MTU 1500 de bout en bout
# hôtes: hv1 hv2
# tickets: #50, #51
on hv1 <<'NODE'
KEY=$(vm_key)
check "hv1 : VPC vp-t41" vpc_create vp-t41 10.41.0.0/16
check "hv1 : subnet sn-t41 (VNI 4101)" subnet_create sn-t41 vp-t41 4101 10.41.1.0/24
check "hv1 : vxlan-4101 porte l'adresse VTEP locale 192.168.14.11" sh -c "ip -d link show vxlan-4101 | grep -q 'local 192.168.14.11 '"
check "hv1 : VM t41-p" vm_create t41-p sn-t41 10.41.1.10 "${KEY}"
NODE
on hv2 <<'NODE'
KEY=$(vm_key)
check "hv2 : VPC vp-t41" vpc_create vp-t41 10.41.0.0/16
check "hv2 : subnet sn-t41 (VNI 4101)" subnet_create sn-t41 vp-t41 4101 10.41.1.0/24
check "hv2 : vxlan-4101 porte l'adresse VTEP locale 192.168.14.12" sh -c "ip -d link show vxlan-4101 | grep -q 'local 192.168.14.12 '"
check "hv2 : VM t41-q" vm_create t41-q sn-t41 10.41.1.11 "${KEY}"
NODE
on hv1 <<'NODE'
check "t41-p joignable" vm_wait vp-t41 10.41.1.10
for i in $(seq 1 30); do vtysh -c "show evpn vni 4101" | grep -q 192.168.14.12 && break; sleep 2; done
check "hv1 : VTEP distant 192.168.14.12 appris par EVPN pour la VNI 4101" sh -c "vtysh -c 'show evpn vni 4101' | grep -q '192.168.14.12'"
check "hv1 : entrée d'inondation vers 192.168.14.12" sh -c "bridge fdb show dev vxlan-4101 | grep -q '00:00:00:00:00:00 dst 192.168.14.12'"
for i in $(seq 1 24); do vm_ssh vp-t41 10.41.1.10 'ping -c 1 -W 2 10.41.1.11' >/dev/null 2>&1 && break; sleep 5; done
check "t41-p (hv1) joint t41-q (hv2)" vm_ssh vp-t41 10.41.1.10 'ping -c 3 -W 2 10.41.1.11'
for i in $(seq 1 24); do vm_ssh vp-t41 10.41.1.10 "timeout 5 bash -c '</dev/tcp/10.41.1.11/22'" >/dev/null 2>&1 && break; sleep 5; done
check "t41-p ouvre une connexion TCP vers t41-q:22" vm_ssh vp-t41 10.41.1.10 "timeout 5 bash -c '</dev/tcp/10.41.1.11/22'"
check "trame pleine taille : 1472 octets en -M do" vm_ssh vp-t41 10.41.1.10 'ping -M do -s 1472 -c 2 -W 2 10.41.1.11'
check "1473 octets refusés localement (MTU 1500)" vm_grep vp-t41 10.41.1.10 'ping -M do -s 1473 -c 1 -W 2 10.41.1.11' 'message too long'
MAC=$(vm_neigh_mac vp-t41 10.41.1.10 10.41.1.11)
check "hv1 : MAC de t41-q résolue par t41-p (${MAC:-aucune})" test -n "${MAC}"
check "hv1 : MAC de t41-q ${MAC} apprise en type 2 via le VTEP de hv2" wait_evpn_mac 4101 "${MAC}" 192.168.14.12
check "hv1 : forme JSON de FRR, chaque MAC distante de la VNI 4101 porte remoteVtep (hypothèse de evpn_mac_remote)" evpn_mac_json_shape 4101
NODE
on hv2 <<'NODE'
check "t41-q joignable" vm_wait vp-t41 10.41.1.11
check "t41-q (hv2) joint t41-p (hv1)" vm_ssh vp-t41 10.41.1.11 'ping -c 3 -W 2 10.41.1.10'
check "t41-q ouvre une connexion TCP vers t41-p:22" vm_ssh vp-t41 10.41.1.11 "timeout 5 bash -c '</dev/tcp/10.41.1.10/22'"
MAC=$(vm_neigh_mac vp-t41 10.41.1.11 10.41.1.10)
check "hv2 : MAC de t41-p résolue par t41-q (${MAC:-aucune})" test -n "${MAC}"
check "hv2 : MAC de t41-p ${MAC} apprise en type 2 via le VTEP de hv1" wait_evpn_mac 4101 "${MAC}" 192.168.14.11
NODE

View file

@ -1,25 +0,0 @@
# fonctionnalité: isolation entre VPC à travers EVPN — deux VPC sur la même plage, la VM d'une VPC ne joint pas celle de l'autre sur un hôte distant
# hôtes: hv1 hv2
# tickets: #50, #51
on hv1 <<'NODE'
KEY=$(vm_key)
check "hv1 : VPC vp-t42a" vpc_create vp-t42a 10.42.0.0/16
check "hv1 : subnet sn-t42a (VNI 4201)" subnet_create sn-t42a vp-t42a 4201 10.42.1.0/24
check "hv1 : VM t42-r dans vp-t42a" vm_create t42-r sn-t42a 10.42.1.10 "${KEY}"
NODE
on hv2 <<'NODE'
check "hv2 : VPC vp-t42a" vpc_create vp-t42a 10.42.0.0/16
check "hv2 : subnet sn-t42a (VNI 4201)" subnet_create sn-t42a vp-t42a 4201 10.42.1.0/24
check "hv2 : VM t42-t dans vp-t42a (témoin)" vm_create t42-t sn-t42a 10.42.1.12
check "hv2 : VPC vp-t42b, même plage" vpc_create vp-t42b 10.42.0.0/16
check "hv2 : subnet sn-t42b (VNI 4202), même plage" subnet_create sn-t42b vp-t42b 4202 10.42.1.0/24
check "hv2 : VM t42-s dans vp-t42b" vm_create t42-s sn-t42b 10.42.1.11
NODE
on hv1 <<'NODE'
check "t42-r joignable" vm_wait vp-t42a 10.42.1.10
for i in $(seq 1 24); do vm_ssh vp-t42a 10.42.1.10 'ping -c 1 -W 2 10.42.1.12' >/dev/null 2>&1 && break; sleep 5; done
check "t42-r joint t42-t, même VPC sur hv2 (témoin)" vm_ssh vp-t42a 10.42.1.10 'ping -c 3 -W 2 10.42.1.12'
check "t42-r ne joint pas t42-s, autre VPC sur hv2, même plage" vm_fails vp-t42a 10.42.1.10 'ping -c 3 -W 2 10.42.1.11'
check "aucune entrée ARP résolue pour 10.42.1.11 dans t42-r" vm_fails vp-t42a 10.42.1.10 'ip neigh show 10.42.1.11 | grep -q lladdr'
NODE

View file

@ -1,42 +0,0 @@
# fonctionnalité: fenêtre ARP de la gateway anycast entre deux hôtes — relais L2 depuis l'adresse d'émission d'un hôte, gateway de la VM inchangée, métadonnées, renouvellement DHCP et TCP local sans perte pendant la fenêtre
# hôtes: hv1 hv2
# tickets: #57
for host in hv1 hv2; do
on "${host}" "HOST=${host}" <<'NODE'
KEY=$(vm_key)
case "${HOST}" in hv1) n=1 ;; hv2) n=2 ;; esac
check "${HOST} : VPC vp-t44, sans l3vni" vpc_create vp-t44 10.44.0.0/16
check "${HOST} : subnet sn-t44a (VNI 4411)" subnet_create sn-t44a vp-t44 4411 10.44.1.0/24
check "${HOST} : subnet sn-t44b (VNI 4412)" subnet_create sn-t44b vp-t44 4412 10.44.2.0/24
check "${HOST} : VM t44-a${n} 10.44.1.1${n}" vm_create "t44-a${n}" sn-t44a "10.44.1.1${n}" "${KEY}"
check "${HOST} : VM t44-b${n} 10.44.2.1${n}" vm_create "t44-b${n}" sn-t44b "10.44.2.1${n}" "${KEY}"
check "${HOST} : t44-a${n} joignable" vm_wait vp-t44 "10.44.1.1${n}"
check "${HOST} : t44-b${n} joignable" vm_wait vp-t44 "10.44.2.1${n}"
NODE
done
on hv2 <<'NODE'
check "prérequis : t44-a2 résout sa gateway vers la MAC anycast" vm_grep vp-t44 10.44.1.12 'ping -n -c 1 -W 2 10.44.1.254 >/dev/null; ip neigh show 10.44.1.254' "lladdr $(anycast_mac 4411) "
rm -f /tmp/t44.log
nohup ip netns exec vp-t44 bash -c 'for i in $(seq 1 80); do if timeout 1 bash -c "</dev/tcp/10.44.1.12/22" 2>/dev/null; then echo "$(date +%T.%N) ok"; else echo "$(date +%T.%N) KO"; fi; sleep 0.5; done' > /tmp/t44.log 2>&1 &
sleep 3
NODE
on hv1 <<'NODE'
check "hv1 : entrées ARP du netns retirées sur sn-t44a" ip -n vp-t44 neigh flush dev br-t44a
check "t44-b1 (hv1) joint t44-a2 (hv2), autre subnet : relais L2 depuis l'adresse d'émission de hv1" vm_ssh vp-t44 10.44.2.11 'ping -n -c 3 -W 2 10.44.1.12'
NODE
on hv2 <<'NODE'
MAC=$(anycast_mac 4411)
check "fenêtre ouverte : t44-a2 associe l'adresse d'émission 10.44.1.253 à la MAC de hv1" vm_grep vp-t44 10.44.1.12 'ip neigh show 10.44.1.253' 'lladdr 02:03:c0:a8:0e:0b '
check "pendant la fenêtre : la gateway de t44-a2 reste la MAC anycast ${MAC}" vm_grep vp-t44 10.44.1.12 'ip neigh show 10.44.1.254' "lladdr ${MAC} "
check "pendant la fenêtre : métadonnées servies à t44-a2" vm_grep vp-t44 10.44.1.12 "python3 -c \"import urllib.request; print(urllib.request.urlopen('http://169.254.169.254/meta-data', timeout=5).read().decode())\"" 'instance-id: t44-a2'
check "pendant la fenêtre : bail renouvelé (networkctl renew)" lease_renewed vp-t44 10.44.1.12
check "bail tenu par la gateway 10.44.1.254" test "$(vm_lease vp-t44 10.44.1.12 SERVER_ADDRESS)" = 10.44.1.254
check "t44-a2 garde son adresse après le renouvellement" has_addr vp-t44 10.44.1.12
for i in $(seq 1 60); do [ "$(wc -l < /tmp/t44.log)" -ge 80 ] && break; sleep 1; done
info "connexions TCP du netns de hv2 vers t44-a2:22 : $(grep -c ' ok$' /tmp/t44.log) réussies, $(grep -c ' KO$' /tmp/t44.log) perdues ; $(grep ' KO$' /tmp/t44.log | head -3 | tr '\n' ' ')"
check "aucune connexion TCP du netns de hv2 vers sa VM perdue pendant la fenêtre (80/80)" test "$(grep -c ' ok$' /tmp/t44.log)" -eq 80
NODE

View file

@ -1,73 +0,0 @@
# fonctionnalité: routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, démontage d'une VPC routée
# hôtes: hv1 hv2
# tickets: #41
on hv1 <<'NODE'
KEY=$(vm_key)
check "hv1 : VPC vp-t51, l3vni 5100" vpc_create vp-t51 10.51.0.0/18 5100
check "hv1 : subnet sn-t51d (VNI 5111), seulement sur hv1" subnet_create sn-t51d vp-t51 5111 10.51.1.0/24
check "hv1 : VM t51-a" vm_create t51-a sn-t51d 10.51.1.10 "${KEY}"
NODE
on hv2 <<'NODE'
check "hv2 : VPC vp-t51, l3vni 5100" vpc_create vp-t51 10.51.0.0/18 5100
check "hv2 : subnet sn-t51e (VNI 5112), seulement sur hv2" subnet_create sn-t51e vp-t51 5112 10.51.2.0/24
check "hv2 : VM t51-b" vm_create t51-b sn-t51e 10.51.2.10
check "hv2 : VPC vp-t51b, même plage, l3vni 5101" vpc_create vp-t51b 10.51.0.0/18 5101
check "hv2 : subnet sn-t51x (VNI 5113), même plage que sn-t51e" subnet_create sn-t51x vp-t51b 5113 10.51.2.0/24
check "hv2 : VM t51-x dans vp-t51b" vm_create t51-x sn-t51x 10.51.2.20
NODE
on hv1 <<'NODE'
check "t51-a joignable" vm_wait vp-t51 10.51.1.10
check "t51-a : route vers la VPC 10.51.0.0/18 via la gateway (DHCP)" route_via vp-t51 10.51.1.10 10.51.0.0/18 10.51.1.254
check "hv1 : vrf-t51 contient exactement brl3-t51 et l3-t51-o" sh -c "[ \"\$1\" = 'brl3-t51 l3-t51-o' ]" _ "$(vrf_members vp-t51)"
check "hv1 : brl3-t51 sans adresse IPv4" sh -c "! ip -4 -o addr show dev brl3-t51 | grep -q inet"
check "hv1 : RMAC de brl3-t51 dérivée du VTEP 192.168.14.11" sh -c "ip -o link show brl3-t51 | grep -q 'link/ether 02:02:c0:a8:0e:0b '"
check "hv1 : route du supernet dans vp-t51 vers le transit" sh -c "ip -n vp-t51 -4 route show 10.51.0.0/18 | grep -q 'via 169.254.0.1 dev l3-t51-i'"
check "hv1 : forwarding sur brl3-t51 et l3-t51-o" sh -c "[ \"\$(sysctl -n net.ipv4.conf.brl3-t51.forwarding net.ipv4.conf.l3-t51-o.forwarding | tr '\n' ' ')\" = '1 1 ' ]"
check "hv1 : ip_forward dans le netns vp-t51" sh -c "[ \"\$(ip netns exec vp-t51 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-t51 exporte le subnet local 10.51.1.0/24 (agent)" vrf_route_via vp-t51 10.51.1.0/24 169.254.0.2
check "hv1 : vrf-t51 exporte t51-a 10.51.1.10/32 (agent)" vrf_route_via vp-t51 10.51.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 : t51-b joignable depuis son netns" netns_ping_wait vp-t51 10.51.2.10
check "hv2 : t51-x joignable depuis son netns (témoin)" netns_ping_wait vp-t51b 10.51.2.20
check "hv2 : VNI 5100 de type L3, active, RMAC 02:02:c0:a8:0e:0c" wait_l3vni 5100 02:02:c0:a8:0e:0c
check "hv2 : VNI 5101 de type L3, active, RMAC 02:02:c0:a8:0e:0c" wait_l3vni 5101 02:02:c0:a8:0e:0c
check "hv2 : vrf-t51 apprend 10.51.1.10/32 via le VTEP de hv1" wait_vrf_route vp-t51 10.51.1.10 192.168.14.11
check "hv2 : vrf-t51 apprend 10.51.1.0/24 via le VTEP de hv1" wait_vrf_route vp-t51 10.51.1.0/24 192.168.14.11
check "hv2 : RMAC de hv1 dans la FDB de vxl3-t51" sh -c "bridge fdb show dev vxl3-t51 | grep -q '02:02:c0:a8:0e:0b dst 192.168.14.11'"
NODE
on rr1 <<'NODE'
check "rr1 : RT-5 10.51.1.10/32 de hv1 (RD 192.168.14.11:5100) reçue et réfléchie" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.11:5100 type prefix' | grep -q '\[10.51.1.10\]'"
check "rr1 : RT-5 10.51.2.20/32 de vp-t51b (RD 192.168.14.12:5101) présente (témoin du test négatif)" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.12:5101 type prefix' | grep -q '\[10.51.2.20\]'"
NODE
on hv1 <<'NODE'
check "hv1 : VNI 5100 de type L3, active, RMAC 02:02:c0:a8:0e:0b" wait_l3vni 5100 02:02:c0:a8:0e:0b
check "hv1 : vrf-t51 apprend 10.51.2.10/32 via le VTEP de hv2" wait_vrf_route vp-t51 10.51.2.10 192.168.14.12
check "hv1 : aucun VXLAN de sn-t51e (VNI 5112) sur hv1" sh -c "! ip link show vxlan-5112 >/dev/null 2>&1"
for i in $(seq 1 24); do vm_ssh vp-t51 10.51.1.10 'ping -c 1 -W 2 10.51.2.10' >/dev/null 2>&1 && break; sleep 5; done
check "t51-a (sn-t51d, hv1) joint t51-b (sn-t51e, hv2) par le L3VNI, forwarding par interface" vm_ssh vp-t51 10.51.1.10 'ping -c 3 -W 2 10.51.2.10'
check "trame pleine taille : 1472 octets en -M do" vm_ssh vp-t51 10.51.1.10 'ping -M do -s 1472 -c 2 -W 2 10.51.2.10'
check "1473 octets refusés localement (MTU 1500)" vm_grep vp-t51 10.51.1.10 'ping -M do -s 1473 -c 1 -W 2 10.51.2.10' 'message too long'
check "TTL 1 : expire à la gateway du subnet, netns de hv1 (10.51.1.254)" vm_grep vp-t51 10.51.1.10 'ping -n -c 3 -i 1.2 -W 2 -t 1 10.51.2.10' 'From 10.51.1.254 .*exceeded'
check "TTL 2 : expire dans la VRF de hv1 (169.254.0.1)" vm_grep vp-t51 10.51.1.10 'ping -n -c 3 -i 1.2 -W 2 -t 2 10.51.2.10' 'From 169.254.0.1 .*exceeded'
check "TTL 5 : atteint t51-b — quatre routeurs : gateway hv1, VRF hv1, VRF hv2, netns hv2" vm_ssh vp-t51 10.51.1.10 'ping -n -c 1 -W 2 -t 5 10.51.2.10'
check "hv1 : vrf-t51 n'importe pas 10.51.2.20/32 de vp-t51b (RT 64600:5101)" sh -c "[ -z \"\$(ip -4 route show vrf vrf-t51 10.51.2.20)\" ]"
check "t51-a ne joint pas t51-x, autre VPC, même plage" vm_fails vp-t51 10.51.1.10 'ping -c 3 -W 2 10.51.2.20'
NODE
on hv2 <<'NODE'
BGPD=$(pidof bgpd)
check "hv2 : suppression de sn-t51x refusée tant que t51-x existe (409)" test "$(api_code DELETE subnets/sn-t51x)" = 409
check "hv2 : suppression de t51-x" vm_delete t51-x
check "hv2 : vrf-t51b ne porte plus le /32 de t51-x" test -z "$(ip -4 route show vrf vrf-t51b 10.51.2.20/32)"
check "hv2 : suppression de sn-t51x" api_delete subnets/sn-t51x
check "hv2 : sn-t51x supprimé" wait_state subnets/sn-t51x deleted
check "hv2 : suppression de vp-t51b" api_delete vpcs/vp-t51b
check "hv2 : vp-t51b supprimé" wait_state vpcs/vp-t51b deleted
check "hv2 : plus aucune interface de vp-t51b" sh -c "! ip -o link show | grep -qE '(vrf|brl3|vxl3)-t51b|l3-t51b-o'"
check "hv2 : plus rien de vrf-t51b dans FRR, en mémoire ni dans frr.conf" sh -c "! vtysh -c 'show running-config' | grep -q 'vrf-t51b' && ! grep -q 'vrf-t51b' /etc/frr/frr.conf"
check "hv2 : bgpd n'a pas redémarré pendant le démontage" sh -c "[ \"\$(pidof bgpd)\" = '${BGPD}' ]"
check "hv2 : vp-t51 toujours en service" wait_l3vni 5100 02:02:c0:a8:0e:0c
NODE

View file

@ -1,89 +0,0 @@
# fonctionnalité: migration d'une adresse de VM entre hôtes d'une VPC routée — /32 retiré en premier, /24 en filet puis en ECMP, séquence orchestrée, 40 sources, suppression du subnet refusée tant qu'une VM l'utilise, MAC anycast hors EVPN
# hôtes: hv1 hv2 hv3
# tickets: #41, #57
on hv1 <<'NODE'
check "hv1 : VPC vp-t52, l3vni 5200" vpc_create vp-t52 10.52.0.0/16 5200
check "hv1 : subnet sn-t52s (VNI 5211)" subnet_create sn-t52s vp-t52 5211 10.52.1.0/24
check "hv1 : VM t52-m1 10.52.1.50" vm_create t52-m1 sn-t52s 10.52.1.50
check "hv1 : t52-m1 répond depuis son netns" netns_ping_wait vp-t52 10.52.1.50
check "hv1 : /24 et /32 exportés par l'agent" sh -c "ip -4 route show vrf vrf-t52 | grep -q '^10.52.1.0/24 via 169.254.0.2' && ip -4 route show vrf vrf-t52 | grep -q '^10.52.1.50 via 169.254.0.2'"
NODE
on hv2 <<'NODE'
check "hv2 : VPC vp-t52, l3vni 5200" vpc_create vp-t52 10.52.0.0/16 5200
check "hv2 : aucun subnet de vp-t52 au départ" sh -c "! ip link show vxlan-5211 >/dev/null 2>&1"
NODE
on hv3 <<'NODE'
KEY=$(vm_key)
check "hv3 : VPC vp-t52, l3vni 5200" vpc_create vp-t52 10.52.0.0/16 5200
check "hv3 : subnet sn-t52t (VNI 5212), seulement sur hv3" subnet_create sn-t52t vp-t52 5212 10.52.2.0/24
check "hv3 : VM observatrice t52-o 10.52.2.10" vm_create t52-o sn-t52t 10.52.2.10 "${KEY}"
check "t52-o joignable" vm_wait vp-t52 10.52.2.10
check "hv3 : aucun VXLAN de sn-t52s sur l'observateur" sh -c "! ip link show vxlan-5211 >/dev/null 2>&1"
check "hv3 : /32 de t52-m1 via hv1 seulement" wait_vrf_nexthops vp-t52 10.52.1.50 192.168.14.11
for i in $(seq 1 24); do vm_ssh vp-t52 10.52.2.10 'ping -c 1 -W 2 10.52.1.50' >/dev/null 2>&1 && break; sleep 5; done
check "t52-o (hv3) joint t52-m1 (hv1)" vm_ssh vp-t52 10.52.2.10 'ping -n -c 3 -W 2 10.52.1.50'
check "1472 octets en -M do" vm_ssh vp-t52 10.52.2.10 'ping -n -M do -s 1472 -c 2 -W 2 10.52.1.50'
NODE
on hv1 <<'NODE'
check "migration simple, 1 — suppression de t52-m1 sur hv1 : son /32 part en premier" vm_delete t52-m1
check "hv1 : plus de /32 pour 10.52.1.50 dans vrf-t52" test -z "$(ip -4 route show vrf vrf-t52 10.52.1.50/32 | grep 169.254.0.2)"
NODE
on hv3 <<'NODE'
check "hv3 : plus aucun /32 pour 10.52.1.50" wait_vrf_nexthops vp-t52 10.52.1.50 ""
check "hv3 : le /24 de sn-t52s reste annoncé par hv1 (filet)" wait_vrf_nexthops vp-t52 10.52.1.0/24 192.168.14.11
NODE
on hv2 <<'NODE'
check "migration simple, 2 — sn-t52s créé sur hv2 (même VNI 5211)" subnet_create sn-t52s vp-t52 5211 10.52.1.0/24
check "migration simple, 3 — VM t52-m2 10.52.1.50 sur hv2" vm_create t52-m2 sn-t52s 10.52.1.50
check "hv2 : t52-m2 répond depuis son netns" netns_ping_wait vp-t52 10.52.1.50
NODE
on hv3 <<'NODE'
start=${SECONDS}
check "hv3 : /32 de 10.52.1.50 via hv2 seulement" wait_vrf_nexthops vp-t52 10.52.1.50 192.168.14.12
info "hv3 : /32 de hv2 installé $(( SECONDS - start )) s après le passage en running de t52-m2"
check "hv3 : /24 de sn-t52s en ECMP vers hv1 et hv2" wait_vrf_nexthops vp-t52 10.52.1.0/24 "192.168.14.11 192.168.14.12"
for i in $(seq 1 24); do vm_ssh vp-t52 10.52.2.10 'ping -c 1 -W 2 10.52.1.50' >/dev/null 2>&1 && break; sleep 5; done
check "t52-o joint t52-m2 par son /32" vm_ssh vp-t52 10.52.2.10 'ping -n -c 3 -W 2 10.52.1.50'
info "après migration simple : $(ping_rate vp-t52 10.52.2.10 10.52.1.50 50)/50 réponses"
NODE
on hv1 <<'NODE'
info "orchestrée, 1 — sn-t52s présent sur hv1 (destination), /24 annoncé"
check "orchestrée, 2 — VM t52-m3 10.52.1.50 sur hv1 pendant que t52-m2 tourne sur hv2" vm_create t52-m3 sn-t52s 10.52.1.50
check "hv1 : t52-m3 répond depuis son netns" netns_ping_wait vp-t52 10.52.1.50
NODE
on rr1 <<'NODE'
MAC=$(anycast_mac 5211)
R=$(vtysh -c 'show bgp l2vpn evpn route type macip')
check "rr1 : routes EVPN de type 2 reçues (témoin)" sh -c 'echo "$1" | grep -q "\[2\]:"' _ "${R}"
check "rr1 : aucune route de type 2 pour la MAC anycast de sn-t52s (${MAC}), présente sur hv1 et hv2" sh -c '! echo "$1" | grep -qi "$2"' _ "${R}" "${MAC}"
NODE
on hv1 <<'NODE'
MAC=$(anycast_mac 5211)
check "hv1 : aucune MAC en double sur la VNI 5211" sh -c "! vtysh -c 'show evpn mac vni 5211 duplicate' | grep -qiE '([0-9a-f]{2}:){5}[0-9a-f]{2}'"
check "hv1 : table EVPN de la VNI 5211 non vide (témoin)" sh -c "vtysh -c 'show evpn mac vni 5211' | grep -qiE '([0-9a-f]{2}:){5}[0-9a-f]{2}'"
check "hv1 : MAC anycast ${MAC} absente de la table EVPN de la VNI 5211" sh -c '! vtysh -c "show evpn mac vni $1" | grep -qi "$2"' _ 5211 "${MAC}"
NODE
on hv3 <<'NODE'
for i in $(seq 1 30); do [ "$(bgp_paths vp-t52 10.52.1.50/32)" -ge 2 ] && break; sleep 2; done
info "orchestrée : chemins BGP pour 10.52.1.50/32 : $(bgp_paths vp-t52 10.52.1.50/32) ; meilleur : $(bgp_best vp-t52 10.52.1.50/32) ; installés : $(vrf_nexthops vp-t52 10.52.1.50)"
check "orchestrée : deux /32 annoncés, hv1 et hv2" wait_vrf_nexthops vp-t52 10.52.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.52.1.50, quel que soit le chemin ECMP" sh -c "[ \"\$1\" = 40/40 ]" _ "$(sources_reach vp-t52 br-t52t 10.52.2 10.52.1.50)"
NODE
on hv2 <<'NODE'
check "orchestrée, 3 — sn-t52s non supprimable sur hv2 tant que t52-m2 existe (409)" test "$(api_code DELETE subnets/sn-t52s)" = 409
check "orchestrée, 4 — suppression de t52-m2 sur hv2 (source) : son /32 part en premier" vm_delete t52-m2
check "orchestrée, 5 — suppression de sn-t52s sur hv2" api_delete subnets/sn-t52s
check "sn-t52s supprimé sur hv2" wait_state subnets/sn-t52s deleted
NODE
on hv3 <<'NODE'
check "hv3 : /32 de 10.52.1.50 via hv1 seulement" wait_vrf_nexthops vp-t52 10.52.1.50 192.168.14.11
check "hv3 : /24 de sn-t52s via hv1 seulement" wait_vrf_nexthops vp-t52 10.52.1.0/24 192.168.14.11
check "après la séquence orchestrée : t52-o joint t52-m3" vm_ssh vp-t52 10.52.2.10 'ping -n -c 3 -W 2 10.52.1.50'
check "après la séquence orchestrée : les 40 sources joignent t52-m3" sh -c "[ \"\$1\" = 40/40 ]" _ "$(sources_reach vp-t52 br-t52t 10.52.2 10.52.1.50)"
NODE
on hv1 <<'NODE'
check "ex-pire cas — suppression de sn-t52s sur hv1 refusée tant que t52-m3 existe (409)" test "$(api_code DELETE subnets/sn-t52s)" = 409
check "ex-pire cas — sn-t52s toujours running sur hv1" test "$(api_state subnets/sn-t52s)" = running
check "ex-pire cas — /32 et /24 toujours exportés par hv1" sh -c "ip -4 route show vrf vrf-t52 | grep -q '^10.52.1.50 via 169.254.0.2' && ip -4 route show vrf vrf-t52 | grep -q '^10.52.1.0/24 via 169.254.0.2'"
NODE

View file

@ -1,36 +0,0 @@
# fonctionnalité: watchdog d'une VPC routée — /32 orphelin signalé comme trou noir, /32 manquant signalé, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais
# hôtes: hv1 hv3
# tickets: #41
on hv1 <<'NODE'
check "hv1 : VPC vp-t53, l3vni 5300" vpc_create vp-t53 10.53.0.0/16 5300
check "hv1 : subnet sn-t53s (VNI 5311)" subnet_create sn-t53s vp-t53 5311 10.53.1.0/24
check "hv1 : VM t53-m 10.53.1.50" vm_create t53-m sn-t53s 10.53.1.50
check "hv1 : t53-m répond depuis son netns" netns_ping_wait vp-t53 10.53.1.50
check "hv1 : /32 de t53-m exporté par l'agent" vrf_route_via vp-t53 10.53.1.50 169.254.0.2
NODE
on hv3 <<'NODE'
KEY=$(vm_key)
check "hv3 : VPC vp-t53, l3vni 5300" vpc_create vp-t53 10.53.0.0/16 5300
check "hv3 : subnet sn-t53t (VNI 5312)" subnet_create sn-t53t vp-t53 5312 10.53.2.0/24
check "hv3 : VM observatrice t53-o 10.53.2.10" vm_create t53-o sn-t53t 10.53.2.10 "${KEY}"
check "t53-o joignable" vm_wait vp-t53 10.53.2.10
check "hv3 : /32 de t53-m via hv1" wait_vrf_nexthops vp-t53 10.53.1.50 192.168.14.11
for i in $(seq 1 24); do vm_ssh vp-t53 10.53.2.10 'ping -c 1 -W 2 10.53.1.50' >/dev/null 2>&1 && break; sleep 5; done
check "avant les essais du watchdog : t53-o joint t53-m (témoin)" vm_ssh vp-t53 10.53.2.10 'ping -n -c 3 -W 2 10.53.1.50'
NODE
on hv1 <<'NODE'
check "watchdog : aucune alerte BGP ni L3VNI avant les essais (témoin)" watchdog_l3_quiet 60
check "watchdog : /32 orphelin posé à la main dans vrf-t53" ip route replace 10.53.1.99/32 via 169.254.0.2 dev l3-t53-o vrf vrf-t53
check "watchdog : /32 orphelin signalé comme trou noir" wait_watchdog "route 10.53.1.99/32 exported in vrf-t53 without a running owner"
check "watchdog : retrait du /32 orphelin" ip route del 10.53.1.99/32 vrf vrf-t53
check "watchdog : /32 de t53-m retiré à la main" ip route del 10.53.1.50/32 vrf vrf-t53
check "hypothèse du test : FRR retire le /32 de t53-m de sa table BGP quand la route du noyau disparaît" wait_bgp_paths vp-t53 10.53.1.50/32 0
check "watchdog : /32 manquant signalé" wait_watchdog "route 10.53.1.50/32 not exported in vrf-t53"
check "watchdog : /32 de t53-m rétabli" ip route replace 10.53.1.50/32 via 169.254.0.2 dev l3-t53-o vrf vrf-t53
check "watchdog : aucune alerte BGP ni L3VNI sur hv1" watchdog_l3_quiet 60
NODE
on hv3 <<'NODE'
check "hv3 : /32 de t53-m de nouveau via hv1" wait_vrf_nexthops vp-t53 10.53.1.50 192.168.14.11
check "après les essais du watchdog : t53-o joint t53-m" vm_ssh vp-t53 10.53.2.10 'ping -n -c 3 -W 2 10.53.1.50'
NODE

View file

@ -1,77 +0,0 @@
# fonctionnalité: redémarrage de l'agent avec des VM en marche — rien ne disparaît ni n'est recréé, trafic routé sans perte, DHCP et métadonnées servis, base BGP réappliquée à l'identique, ressources toujours gérées
# hôtes: hv1 hv2
# tickets: #41, #46
on hv1 <<'NODE'
KEY=$(vm_key)
check "hv1 : VPC vp-t61, l3vni 6100" vpc_create vp-t61 10.61.0.0/16 6100
check "hv1 : subnet sn-t61a (VNI 6111)" subnet_create sn-t61a vp-t61 6111 10.61.1.0/24
check "hv1 : VM t61-a 10.61.1.10" vm_create t61-a sn-t61a 10.61.1.10 "${KEY}"
check "hv1 : VM t61-d 10.61.1.11, supprimée après le redémarrage" vm_create t61-d sn-t61a 10.61.1.11 "${KEY}"
NODE
on hv2 <<'NODE'
check "hv2 : VPC vp-t61, l3vni 6100" vpc_create vp-t61 10.61.0.0/16 6100
check "hv2 : subnet sn-t61b (VNI 6112)" subnet_create sn-t61b vp-t61 6112 10.61.2.0/24
check "hv2 : VM t61-b 10.61.2.10" vm_create t61-b sn-t61b 10.61.2.10
check "hv2 : t61-b répond depuis son netns" netns_ping_wait vp-t61 10.61.2.10
NODE
on hv1 <<'NODE'
api_snapshot () {
for kind in vpcs subnets vms; do
curl -fsS "${API}/${kind}" | jq -r --arg k "${kind}" '.[] | "\($k) \(.name) \(.state)"'
done | sort
}
dropped () { vtysh -c "show bgp neighbors ${1}" | grep -o 'dropped [0-9]*'; }
same_as () { local d; d=$(diff "${1}" <("${2}")) && return 0; printf '%s\n' "${d}" | tail -n 3; return 1; }
mkdir -p "${STATE_DIR}"
check "t61-a joignable" vm_wait vp-t61 10.61.1.10
check "t61-d joignable" vm_wait vp-t61 10.61.1.11
check "hv1 : vrf-t61 apprend 10.61.2.10/32 via le VTEP de hv2" wait_vrf_route vp-t61 10.61.2.10 192.168.14.12
for i in $(seq 1 24); do vm_ssh vp-t61 10.61.1.10 'ping -c 1 -W 2 10.61.2.10' >/dev/null 2>&1 && break; sleep 5; done
check "prérequis : t61-a (hv1) joint t61-b (hv2) par le L3VNI" vm_ssh vp-t61 10.61.1.10 'ping -n -c 3 -W 2 10.61.2.10'
QEMU=$(pgrep -f "${VOLUMES}/t61-a.qcow2" | sort | tr '\n' ' ')
QEMU_D=$(pgrep -f "${VOLUMES}/t61-d.qcow2" | sort | tr '\n' ' ')
check "prérequis : processus QEMU de t61-a et t61-d relevés (${QEMU:-?} / ${QEMU_D:-?})" test -n "${QEMU}" -a -n "${QEMU_D}"
host_state > "${STATE_DIR}/t61.restart"
api_snapshot > "${STATE_DIR}/t61.api"
for rr in 10.255.255.1 10.255.255.2; do dropped "${rr}" > "${STATE_DIR}/t61.${rr}"; done
vm_ssh vp-t61 10.61.1.10 'rm -f /tmp/t61.log; nohup ping -D -i 0.2 10.61.2.10 > /tmp/t61.log 2>&1 &'
sleep 5
START=$(date +%s)
check "hv1 : redémarrage de l'agent" systemctl restart agent
for i in $(seq 1 30); do curl -fsS -o /dev/null "${API}/vpcs" 2>/dev/null && break; sleep 1; done
info "API de nouveau joignable $(( $(date +%s) - START )) s après la demande de redémarrage"
check "après redémarrage : agent actif et API joignable" sh -c "systemctl is-active --quiet agent && curl -fsS -o /dev/null '${API}/vpcs'"
check "après redémarrage : base BGP réappliquée au démarrage" sh -c "journalctl -u agent --since '@${START}' --no-pager -o cat | grep -qF 'bgp base configuration applied'"
sleep 20
check "après redémarrage : même processus QEMU pour t61-a (ni arrêtée ni recréée)" test "$(pgrep -f "${VOLUMES}/t61-a.qcow2" | sort | tr '\n' ' ')" = "${QEMU}"
check "après redémarrage : même processus QEMU pour t61-d" test "$(pgrep -f "${VOLUMES}/t61-d.qcow2" | sort | tr '\n' ' ')" = "${QEMU_D}"
check "après redémarrage : mêmes fichiers sous /run/two, /etc/dnsmasq.d et les volumes (sinon, fichiers en cause)" section_unchanged "${STATE_DIR}/t61.restart" fichiers
check "après redémarrage : hôte inchangé (netns, liens, taps, adresses, routes, ebtables, iptables, FRR, frr.conf, fichiers, unités)" same_as "${STATE_DIR}/t61.restart" host_state
check "après redémarrage : l'API rend les mêmes ressources dans le même état" same_as "${STATE_DIR}/t61.api" api_snapshot
for rr in 10.255.255.1 10.255.255.2; do
check "après redémarrage : session EVPN vers ${rr} établie, jamais coupée" sh -c "vtysh -c 'show bgp neighbors ${rr}' | grep -q 'BGP state = Established' && [ \"\$(vtysh -c 'show bgp neighbors ${rr}' | grep -o 'dropped [0-9]*')\" = \"\$(cat '${STATE_DIR}/t61.${rr}')\" ]"
done
check "après redémarrage : vrf-t61 exporte toujours t61-a 10.61.1.10/32" vrf_route_via vp-t61 10.61.1.10 169.254.0.2
check "après redémarrage : vrf-t61 apprend toujours 10.61.2.10/32 via hv2" vrf_route_via vp-t61 10.61.2.10 192.168.14.12
check "après redémarrage : bail de t61-a renouvelé (DHCP servi)" lease_renewed vp-t61 10.61.1.10
check "après redémarrage : métadonnées de t61-a servies (instance-id t61-a)" vm_grep vp-t61 10.61.1.10 'curl -fsS http://169.254.169.254/meta-data' 't61-a'
check "après redémarrage : aucune incohérence signalée par le watchdog (hors réservation DHCP périmée, #78)" watchdog_quiet "$(( $(date +%s) - START ))" 'stale dhcp reservation'
known_flaky "#78" "après redémarrage : aucune réservation DHCP signalée périmée par le watchdog" watchdog_quiet_about "$(( $(date +%s) - START ))" 'stale dhcp reservation'
vm_ssh vp-t61 10.61.1.10 'pkill -x ping' || true
sleep 1
stats=$(vm_ssh vp-t61 10.61.1.10 "awk -F'icmp_seq=' '/bytes from/ {split(\$2, a, \" \"); n++; if (a[1] > max) max = a[1]} END {print n+0, max+0}' /tmp/t61.log")
received=${stats% *}
sent=${stats#* }
gap=$(vm_ssh vp-t61 10.61.1.10 "LC_ALL=C awk -F'[][]' '/bytes from/ {if (prev != \"\" && \$2 - prev > max) max = \$2 - prev; prev = \$2} END {printf \"%d\", max * 10}' /tmp/t61.log")
info "trafic routé t61-a → t61-b pendant le redémarrage : ${received} réponses pour ${sent} requêtes ; plus long silence : $(( ${gap:-0} / 10 )),$(( ${gap:-0} % 10 )) s"
check "trafic routé pendant le redémarrage : au moins 100 requêtes émises (témoin)" test "${sent:-0}" -ge 100
check "trafic routé pendant le redémarrage : au plus 1 % de perte" test $(( (${sent:-0} - ${received:-0}) * 100 )) -le "${sent:-0}"
check "après redémarrage : suppression de t61-d acceptée et menée à terme" vm_delete t61-d
check "après redémarrage : processus QEMU de t61-d arrêté" sh -c "! pgrep -f '${VOLUMES}/[t]61-d.qcow2' >/dev/null"
check "après redémarrage : unité two-vm-t61-d.scope retirée" sh -c "! systemctl list-units --all --plain --no-legend 'two-vm-t61-d.scope' | grep -q ."
check "après redémarrage : VM t61-c créée sur le même subnet" vm_create t61-c sn-t61a 10.61.1.12 "$(vm_key)"
check "t61-c joignable" vm_wait vp-t61 10.61.1.12
check "t61-c (créée après le redémarrage) joint t61-b (hv2)" vm_ssh vp-t61 10.61.1.12 'ping -n -c 3 -W 2 10.61.2.10'
NODE

View file

@ -1,27 +0,0 @@
# fonctionnalité: nettoyage global en fin de suite — aucun hôte ne garde de ressource : API vide, ni netns, tap, VRF, unité, instance DHCP ou de métadonnées, processus QEMU, règle de port, volume ; FRR réduit à la base BGP
# hôtes:
# tickets: #70
for host in hv1 hv2 hv3; do
on "${host}" "HOST=${host}" <<'NODE'
none () { local out; out=$("$@" 2>/dev/null) || true; [ -z "${out}" ] && return 0; printf '%s\n' "${out}" | head -n 3; return 1; }
check "${HOST} : API joignable (témoin)" curl -fsS -o /dev/null "${API}/vpcs"
for kind in vms subnets vpcs; do
check "${HOST} : aucune ressource ${kind} non supprimée dans l'API" none api_names "${kind}"
done
check "${HOST} : aucun netns de VPC" none sh -c "ip netns list | awk '{print \$1}' | grep '^vp-'"
check "${HOST} : aucun tap" none sh -c "ip -o link show | awk -F': ' '{print \$2}' | grep '^tap'"
check "${HOST} : aucune interface de subnet (v-*, vxlan-*)" none sh -c "ip -o link show | awk -F': ' '{print \$2}' | cut -d@ -f1 | grep -E '^(v-|vxlan-)'"
check "${HOST} : aucune VRF de VPC (vrf-*)" none sh -c "ip -o link show type vrf | awk -F': ' '{print \$2}' | grep '^vrf-'"
check "${HOST} : aucune unité two-vm-*" none systemctl list-units --all --plain --no-legend 'two-vm-*'
check "${HOST} : aucune instance DHCP (dhcp@, dnsmasq@) ni de métadonnées (metadata@) active" none sh -c "systemctl list-units --plain --no-legend 'dhcp@*' 'dnsmasq@*' 'metadata@*' | grep -w active"
known "#77" "${HOST} : aucun socket de contrôle DHCP" none sh -c "ls /run/two/dhcp/*.sock 2>/dev/null"
check "${HOST} : aucun processus QEMU" none pgrep -a qemu-system
check "${HOST} : aucune règle ebtables qui vise une interface de subnet" none sh -c "{ ebtables -t filter -L; ebtables -t nat -L; } | grep -E -- '-(i|o) v-'"
check "${HOST} : aucune règle iptables qui vise une interface de subnet ou de VPC" none sh -c "iptables-save | grep -E -- '(v-|vp-|tap)[a-z0-9]'"
check "${HOST} : aucun volume de VM de test" none sh -c "ls '${VOLUMES}'/t[0-9][0-9]-* 2>/dev/null"
check "${HOST} : FRR garde la base BGP (témoin)" sh -c "vtysh -c 'show running-config' | grep -q 'peer-group fabric'"
check "${HOST} : FRR sans aucune VRF de VPC (en mémoire)" none sh -c "vtysh -c 'show running-config' | grep -E '^(vrf |router bgp [0-9]+ vrf )'"
check "${HOST} : frr.conf sans aucune VRF de VPC" none grep -E '^(vrf |router bgp [0-9]+ vrf )' /etc/frr/frr.conf
NODE
done

View file

@ -4,7 +4,3 @@ bgp:
watchdog:
enabled: true
interval_seconds: 10
dhcp:
backend: dnsmasq
interfaces:
lan: br-lan

View file

@ -6,5 +6,3 @@ bgp:
watchdog:
enabled: true
interval_seconds: 10
interfaces:
lan: br-lan

View file

@ -10,9 +10,6 @@ segments:
routers: [sw1, sw2]
cidr: 192.168.14.0/24
mtu: 9000
lan:
cidr: 10.33.0.0/24
mtu: 1500
nodes:
sw1:
@ -32,14 +29,12 @@ nodes:
addresses: { underlay: 192.168.14.5 }, secondary: { underlay: [169.254.0.4/28] },
loopback: 10.255.255.2/32, frr: frr/rr2.conf }
hv1:
{ role: host, image: debian12, cpus: 4, memory: 16384,
segments: [underlay, lan], addresses: { underlay: 192.168.14.11, lan: 10.33.0.11 },
frr: frr/hv1.conf, provision: provision/hypervisor.sh,
{ role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.11 }, frr: frr/hv1.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin },
services: [agent.service] }
hv2:
{ role: host, image: debian12, cpus: 4, memory: 16384,
segments: [underlay, lan], addresses: { underlay: 192.168.14.12, lan: 10.33.0.12 },
frr: frr/hv2.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin },
{ role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.12 }, frr: frr/hv2.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/bgp.yml, bin: bin },
services: [agent.service] }

View file

@ -10,9 +10,6 @@ segments:
routers: [sw1, sw2]
cidr: 192.168.14.0/24
mtu: 9000
lan:
cidr: 10.33.0.0/24
mtu: 1500
nodes:
sw1:
@ -32,19 +29,17 @@ nodes:
addresses: { underlay: 192.168.14.5 }, secondary: { underlay: [169.254.0.4/28] },
loopback: 10.255.255.2/32, frr: frr/rr2.conf }
hv1:
{ role: host, image: debian12, cpus: 4, memory: 16384,
segments: [underlay, lan], addresses: { underlay: 192.168.14.11, lan: 10.33.0.11 },
frr: frr/hv1.conf, provision: provision/hypervisor.sh,
{ role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.11 }, frr: frr/hv1.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin },
services: [agent.service] }
hv2:
{ role: host, image: debian12, cpus: 4, memory: 16384,
segments: [underlay, lan], addresses: { underlay: 192.168.14.12, lan: 10.33.0.12 },
frr: frr/hv2.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin },
{ role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.12 }, frr: frr/hv2.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/bgp.yml, bin: bin },
services: [agent.service] }
hv3:
{ role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.13 }, frr: frr/hv3.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin },
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/bgp.yml, bin: bin },
services: [agent.service] }

View file

@ -10,17 +10,6 @@ until curl -fsS -o /dev/null "${GIT_SERVER}"; do
sleep 10
done
install -D -m 0640 "${LAB_FILES}/agent.yml" /etc/two/agent.yml
if [ -e /sys/class/net/lan ]; then
addr=$(ip -4 -o addr show dev lan | awk '{print $4}' | head -n 1)
ip link show br-lan >/dev/null 2>&1 || ip link add name br-lan type bridge stp_state 0
ip link set dev br-lan mtu "$(cat /sys/class/net/lan/mtu)"
ip link set dev lan master br-lan
ip link set dev br-lan up
if [ -n "${addr}" ]; then
ip addr del "${addr}" dev lan
ip addr replace "${addr}" dev br-lan
fi
fi
mkdir -p /opt/two/scripts
cd /opt/two/scripts
for script in deploy.sh bootstrap_kvm.sh; do