diff --git a/.gitignore b/.gitignore index 8ed7508..3f0d6a4 100644 --- a/.gitignore +++ b/.gitignore @@ -37,5 +37,3 @@ docs/_build/ # Binaires compilés en local pour le lab (test/e2e/build.sh) test/e2e/topologies/bin/* !test/e2e/topologies/bin/.gitkeep -test/e2e/topologies/scripts/* -!test/e2e/topologies/scripts/.gitkeep diff --git a/api/agent.yaml b/api/agent.yaml index 40e0400..65c2603 100644 --- a/api/agent.yaml +++ b/api/agent.yaml @@ -91,7 +91,7 @@ paths: "404": $ref: "#/components/responses/NotFound" "409": - description: VPC not deletable — only running or error states can be deleted, and all its subnets must be deleted or deleting; subnets still deleting are awaited by the asynchronous deletion + description: VPC not deletable — only running or error states can be deleted, and all its subnets must be deleted first content: application/json: schema: @@ -234,8 +234,7 @@ paths: "400": description: > Missing required field; interface_ip missing on a bridge or public_ip subnet, or - supplied on a vxlan subnet (it is computed); default_route true without gateway on a - vxlan or public_ip subnet + supplied on a vxlan subnet (it is computed) content: application/json: schema: @@ -289,7 +288,7 @@ paths: "404": $ref: "#/components/responses/NotFound" "409": - description: Subnet not deletable — only running or error states can be deleted, and every VM with an interface on it must be deleted or deleting; VMs still deleting are awaited by the asynchronous deletion + description: Subnet not deletable — only running or error states can be deleted, and no VM that is not deleted may still have an interface on it content: application/json: schema: @@ -409,9 +408,8 @@ components: description: > A default route is always advertised via DHCP; this flag only chooses its next-hop. When false, the next-hop is the subnet interface_ip. When true, it is the `gateway` - field if supplied, otherwise the gateway read from the host routing table — this last - case is bridge mode only (400 in vxlan and public_ip modes, whose guests do not share - the L2 segment of the host gateway). The route to the VPC CIDR always keeps interface_ip as its next-hop (except in bridge + field if supplied, otherwise the gateway read from the host routing table. + The route to the VPC CIDR always keeps interface_ip as its next-hop (except in bridge mode, which has no VPC route), so VPC traffic never leaves through a public gateway. default: false gateway: diff --git a/conf/agent/config.exemple.yml b/conf/agent/config.exemple.yml index 09ab413..3d95b94 100644 --- a/conf/agent/config.exemple.yml +++ b/conf/agent/config.exemple.yml @@ -19,32 +19,20 @@ worker: # Maximum number of commands queued before Dispatch blocks buffer_size: 100 -# Timing (in seconds) for commands that wait on resource state transitions -times: - # Graceful VM shutdown before QMP quit - timeout_vms_stop: 300 - # Interval between two system_powerdown during the shutdown - next_vms_shutdown: 30 - # Subnet deletion: wait for its VMs still deleting - timeout_subnet_stop: 360 - # VPC deletion: wait for its subnets still deleting - timeout_vpc_stop: 420 - # Subnet creation: wait for its VPC to be running - timeout_subnet_start: 300 - # VM creation: wait for the subnets of its interfaces to be running - timeout_vms_start: 300 - # Interval between each state check - poll_interval: 2 +# Timing for commands that wait on resource state transitions +dispatcher: + # How long (in seconds) to wait before giving up + timeout_seconds: 300 + # Interval (in seconds) between each state check + poll_seconds: 2 # Bridge interface used when the requested iface_type is not found in interfaces default_interface: br-000000 -# Map of logical interface types to physical bridge names on this host. -# internet: public bridge, carrying vxlan-public (deploy.sh --public_vni); every VPC -# plugs its vp--e veth into it. br-public when absent, never default_interface. +# Map of logical interface types to physical bridge names on this host interfaces: vms: br-000000 - internet: br-public + internet: br-000000 admin: br-000000 # MTU, identical on every hypervisor. diff --git a/docs/architecture/contraintes.rst b/docs/architecture/contraintes.rst index 636796b..5686cee 100644 --- a/docs/architecture/contraintes.rst +++ b/docs/architecture/contraintes.rst @@ -29,13 +29,6 @@ Réseau * **La route du subnet garde la gateway pour source** (``src``) : le netns parle à ses VM depuis la gateway, leurs réponses reviennent à l'hôte local. Depuis l'adresse d'émission, partagée par tous les hôtes, une réponse peut partir vers un autre hôte. -* **Chaque VRF de VPC porte une route ``unreachable default`` de métrique maximale.** Sans elle, - une recherche manquée dans la VRF retombe dans la table ``main`` de l'hôte et le paquet du - locataire sort par l'underlay. Elle survit à la suppression de la VRF (aucune interface) : la - retirer explicitement au démontage. -* **``default_route: true`` sans ``gateway`` est réservé au mode ``bridge``** : en ``vxlan``, la - gateway de l'hôte n'est pas sur le subnet, la route par défaut serait inutilisable, et jointe - elle contournerait le netns et la VRF. * ``169.254.169.254`` est centralisé dans ``metadata.ServiceIP`` — ne pas le réécrire en dur. QEMU et VM @@ -50,8 +43,7 @@ QEMU et VM exécuté par le processus appelant et hérite du netns posé par ``netns.Call``. Une unit transitoire, forkée par PID 1, démarrerait dans le netns racine et ne verrait pas le tap. * L'arrêt d'une VM ne touche **jamais** aux fichiers disque. En revanche, un ``quit`` brutal est - envoyé à l'expiration de ``times.timeout_vms_stop``. ``system_powerdown`` est renvoyé toutes les - ``times.next_vms_shutdown`` : un appui ACPI arrivé avant que l'invité sache le traiter est perdu. + envoyé à l'expiration de ``dispatcher.timeout_seconds``. Arrêt de l'agent ---------------- diff --git a/docs/concepts/cycle-de-vie.rst b/docs/concepts/cycle-de-vie.rst index adcc57b..bf41484 100644 --- a/docs/concepts/cycle-de-vie.rst +++ b/docs/concepts/cycle-de-vie.rst @@ -40,10 +40,7 @@ Suppression Elle n'est autorisée que depuis ``running`` ou ``error`` — sinon **409**. Depuis ``error``, elle est **best-effort** : les ressources système peuvent n'avoir été créées que partiellement. -Un VPC ne peut être supprimé qu'une fois tous ses subnets supprimés ou en ``deleting``, un subnet -qu'une fois toutes ses VM supprimées ou en ``deleting``. Les enfants encore en ``deleting`` sont -attendus (``times.timeout_vpc_stop``, ``times.timeout_subnet_stop``) ; si l'un d'eux passe en -``error``, la suppression du parent échoue, et le parent passe en ``error`` à son tour. +Un VPC ne peut être supprimé qu'une fois tous ses subnets supprimés. Pas de rollback --------------- diff --git a/docs/concepts/modes-reseau.rst b/docs/concepts/modes-reseau.rst index 0e36516..8a0503d 100644 --- a/docs/concepts/modes-reseau.rst +++ b/docs/concepts/modes-reseau.rst @@ -172,9 +172,7 @@ seule. Le champ ``default_route`` ne choisit que son next-hop : ``default_route: true`` next-hop = le champ ``gateway`` s'il est fourni, sinon la gateway lue dans la table de routage - de l'host, à la création du subnet. Ce dernier cas est **réservé au mode** ``bridge``, où la VM - partage le L2 de cette gateway : sans ``gateway``, ``default_route: true`` est refusé (400) en - ``vxlan`` et en ``public_ip``. + de l'host. ``gateway`` n'est **pas validé** par l'agent : sa joignabilité et sa cohérence avec le CIDR du subnet relèvent de l'appelant. Fourni avec ``default_route: false``, il est ignoré. diff --git a/docs/concepts/vpc-subnet-vm.rst b/docs/concepts/vpc-subnet-vm.rst index 0c9e850..5156a38 100644 --- a/docs/concepts/vpc-subnet-vm.rst +++ b/docs/concepts/vpc-subnet-vm.rst @@ -44,7 +44,7 @@ subnets. L'agent n'impose que la première borne (le RD ``:`` porte .. code-block:: text - vrf- VRF, table de routage = l3vni, unreachable default metric 4278198272 + vrf- VRF, table de routage = l3vni ├── brl3- bridge sans adresse, MAC de routeur 02:02: │ └── vxl3- VXLAN du l3vni, VTEP = IPv4 primaire de default_interface └── l3--o 169.254.0.1/30 ── l3--i 169.254.0.2/30, dans le netns du VPC @@ -56,18 +56,8 @@ touche pas au réglage global, que ``bootstrap_kvm.sh`` met déjà à 1. FRR re ``router bgp vrf vrf-`` avec RD ``:`` et RT ``:``, et l'export des routes du ``cidr`` présentes dans la VRF. -La table de la VRF reçoit, juste après sa création, une route ``unreachable default`` de métrique -maximale (``4278198272``, valeur recommandée par la documentation VRF du noyau). Sans elle, une -recherche qui échoue dans la VRF continue dans les règles suivantes, donc dans la table ``main`` -de l'hôte : un paquet d'un locataire vers une adresse inconnue de la VRF sortirait par l'underlay, -avec ``169.254.0.2`` pour source (mesuré, `#81 `_). La -métrique maximale laisse passer avant elle toute route réelle de la VRF. Cette route n'est pas -annoncée en EVPN : le route-map de la VRF n'exporte que le ``cidr`` du VPC. Elle n'est liée à -aucune interface et ne disparaît pas avec la VRF : la suppression la retire explicitement. IPv4 -seulement. - -La suppression retire d'abord la configuration de routage de FRR, puis les interfaces, la route -``unreachable default``, puis la VRF de FRR. Cet ordre est imposé : supprimer la VRF du noyau sous une instance BGP encore +La suppression retire d'abord la configuration de routage de FRR, puis les interfaces, puis la +VRF de FRR. Cet ordre est imposé : supprimer la VRF du noyau sous une instance BGP encore configurée fait planter ``bgpd`` (FRR 10.7.1). Subnet diff --git a/docs/demarrage/premier-vpc.rst b/docs/demarrage/premier-vpc.rst index b55693f..534dd55 100644 --- a/docs/demarrage/premier-vpc.rst +++ b/docs/demarrage/premier-vpc.rst @@ -48,7 +48,7 @@ La réponse est un **202** : la création est acceptée, pas terminée. Un subnet peut être demandé dès maintenant : il est accepté tant que le VPC est en ``creating`` ou ``running``, et sa création attend que le VPC soit ``running``, dans la limite de -``times.timeout_subnet_start``. Il n'est refusé en **422** que si le VPC est absent, en ``error`` +``dispatcher.timeout_seconds``. Il n'est refusé en **422** que si le VPC est absent, en ``error`` ou en ``deleting``. Le modèle d'attente est décrit dans :doc:`/exploitation/api-agent/asynchronisme`. 2. Le subnet diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index 2b195db..323c66c 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -129,10 +129,10 @@ ne change pas. Le bridge n'est créé qu'au premier démarrage, comme le reste d **Bordures (``evpn-3hv``, #87).** ``bd1`` et ``bd2`` (``192.168.14.21`` et ``.22``) jouent les routeurs de bordure du segment public. Ce sont des nœuds ``host`` sans agent : leur provision -(``test/e2e/topologies/provision/border.sh``) crée ``br-public``, y accroche ``vxlan-public`` -(VNI 1, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway -anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:00:00:01`` (la MAC anycast -de two pour le VNI 1), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface +(``test/e2e/topologies/provision/border.sh``) crée ``br-public``, y accroche ``vxlan-66001`` +(VNI 66001, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway +anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:01:01:d1`` (la MAC anycast +de two pour le VNI 66001), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface ``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur — iBGP AS 64600 vers les deux route reflectors, ``advertise-all-vni`` — plus ``advertise-default-gw`` : la MAC et l'IP de la gateway sont annoncées en type 2 avec la communauté *Default Gateway* (RFC 7432, §7.8 et @@ -313,11 +313,11 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé * - ``11-validation`` - validation de l'API — refus synchrones (400, 409, 422) des VPC, subnets et VM, sans trace en base - hv1 - - #41, #57, #33, #62, #74, #81 + - #41, #57, #33, #62, #74 * - ``12-etats`` - - machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom + - machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom - hv1 - - #41, #84, #79 + - #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 @@ -387,17 +387,17 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé - 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, unreachable default dans la VRF, démontage d'un VPC routé + - 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'un VPC routé - hv1 hv2 - - #41, #81 + - #41 * - ``52-migration`` - migration d'une adresse de VM entre hôtes d'un VPC routé — /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'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, unreachable default absente signalée, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais + - watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais - hv1 hv3 - - #41, #81 + - #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 @@ -433,7 +433,7 @@ tests ont été corrigées sur le serveur et les tests concernés rejoués. Il r établie**. ``72-perte-switch`` n'exige donc plus que le plus prioritaire redevienne maître : il vérifie qu'il n'y a qu'un maître, note lequel, et mesure le plus long silence après le retour ; * une suppression de VM peut durer 300 s quand l'invité ignore l'arrêt ACPI (#79) : ``wait_state`` - attend jusqu'à 480 s, au-delà du ``times.timeout_vpc_stop`` par défaut (420 s). + attend jusqu'à 360 s. Hypothèses vérifiées en lab, à garder en tête en écrivant un test : diff --git a/docs/exploitation/api-agent/asynchronisme.rst b/docs/exploitation/api-agent/asynchronisme.rst index 926ae54..7c4875b 100644 --- a/docs/exploitation/api-agent/asynchronisme.rst +++ b/docs/exploitation/api-agent/asynchronisme.rst @@ -44,18 +44,14 @@ un état stable. Trois règles pour un appelant robuste : -* **Toujours borner l'attente.** Côté agent, la section ``times`` de la configuration borne les - opérations qui attendent une transition ; l'appelant doit avoir sa propre borne. +* **Toujours borner l'attente.** Côté agent, ``dispatcher.timeout_seconds`` (300 s par défaut) + borne les opérations qui attendent une transition ; l'appelant doit avoir sa propre borne. * **Traiter ``error`` comme terminal, pas comme un échec transitoire.** Un ``Execute`` en échec ne se rejoue pas tout seul. * **Savoir ce qui s'enchaîne.** Créer un subnet dont le VPC est encore en ``creating``, ou démarrer une VM sur un subnet en ``creating``, est accepté : l'``Execute`` attend que le parent - passe ``running``, dans la limite de ``times.timeout_subnet_start`` ou ``times.timeout_vms_start`` ; - au-delà, la ressource passe en ``error``. Le refus en 422 ne vaut que pour un parent absent, en - ``error`` ou en ``deleting``. À la suppression, c'est l'inverse : une VM puis son subnet, ou un - subnet puis son VPC, peuvent être supprimés d'un coup ; le parent attend que ses enfants en - ``deleting`` soient supprimés (``times.timeout_subnet_stop``, ``times.timeout_vpc_stop``), et passe - en ``error`` si l'un d'eux échoue. + passe ``running``, dans la limite de ``dispatcher.timeout_seconds`` ; au-delà, la ressource passe + en ``error``. Le refus en 422 ne vaut que pour un parent absent, en ``error`` ou en ``deleting``. Codes de retour --------------- @@ -82,8 +78,8 @@ Codes de retour * - ``409`` - conflit d'existence ou d'état : ressource déjà créée, ou suppression depuis un état qui ne l'autorise pas ; pour un VPC, subnets encore présents, ``l3vni`` déjà utilisée par un - autre VPC, ou ``l3vni`` demandée sans section ``bgp`` ; pour un subnet, VM qui l'utilisent - encore, ni supprimées ni en ``deleting`` + autre VPC, ou ``l3vni`` demandée sans section ``bgp`` ; pour un subnet, VM non supprimées + qui l'utilisent encore * - ``422`` - dépendance absente ou inutilisable : VPC parent d'un subnet, subnet d'une VM, absent, en ``error`` ou en ``deleting`` ; ``mode`` de subnet inconnu ; CIDR ``vxlan`` invalide ou plus diff --git a/docs/exploitation/configuration.rst b/docs/exploitation/configuration.rst index fcbdc61..30cb353 100644 --- a/docs/exploitation/configuration.rst +++ b/docs/exploitation/configuration.rst @@ -72,49 +72,21 @@ Exécution des commandes count: 4 buffer_size: 100 - times: - timeout_vms_stop: 300 - next_vms_shutdown: 30 - timeout_subnet_stop: 360 - timeout_vpc_stop: 420 - timeout_subnet_start: 300 - timeout_vms_start: 300 - poll_interval: 2 + dispatcher: + timeout_seconds: 300 + poll_seconds: 2 ``worker.count`` est le nombre de goroutines qui exécutent les commandes ; ``buffer_size`` le nombre de commandes en attente au-delà duquel ``Dispatch`` bloque. -La section ``times`` règle, en secondes, les attentes des commandes asynchrones : - -``timeout_vms_stop`` - arrêt propre d'une VM : au-delà, QEMU reçoit un ``quit`` QMP. -``next_vms_shutdown`` - intervalle entre deux ``system_powerdown`` pendant cet arrêt. Un invité qui n'écoutait pas - encore l'ACPI au premier appui (firmware, chargeur de démarrage) s'éteint au suivant. -``timeout_subnet_stop`` - suppression d'un subnet : attente de ses VM encore en ``deleting``. -``timeout_vpc_stop`` - suppression d'un VPC : attente de ses subnets encore en ``deleting``. -``timeout_subnet_start`` - création d'un subnet : attente de son VPC ``running``. -``timeout_vms_start`` - création d'une VM : attente des subnets de ses interfaces ``running``. -``poll_interval`` - pas de toutes ces attentes. - -Chaque valeur doit être strictement positive, et ``next_vms_shutdown`` inférieur à -``timeout_vms_stop`` ; sinon l'agent refuse de démarrer. Les attentes s'enchaînent — une VM, -puis son subnet, puis le VPC : garder ``timeout_vms_stop`` < ``timeout_subnet_stop`` < -``timeout_vpc_stop`` pour qu'une suppression en cascade envoyée d'un coup aboutisse. - -L'ancienne section ``dispatcher`` (``timeout_seconds``, ``poll_seconds``) n'est plus lue : restée -dans un fichier, elle est ignorée. +``dispatcher.timeout_seconds`` borne les opérations qui attendent une transition d'état, dont +l'extinction d'une VM. .. warning:: - À l'expiration de ``timeout_vms_stop``, une VM qui ne s'est pas éteinte reçoit un ``quit`` - QMP — un arrêt **brutal**. Pour des charges dont l'extinction est lente (bases de données, - construction d'images), une valeur confortable évite un système de fichiers invité incohérent. + À l'expiration de ce délai, une VM qui ne s'est pas éteinte reçoit un ``quit`` QMP — un arrêt + **brutal**. Pour des charges dont l'extinction est lente (bases de données, construction + d'images), une valeur confortable évite un système de fichiers invité incohérent. Correspondance des interfaces ----------------------------- diff --git a/docs/exploitation/observabilite.rst b/docs/exploitation/observabilite.rst index 34c1197..46d1a37 100644 --- a/docs/exploitation/observabilite.rst +++ b/docs/exploitation/observabilite.rst @@ -45,10 +45,7 @@ Avec une section ``bgp`` dans la configuration, il contrôle aussi le plan de co ``Established`` (``show bgp neighbors ``). * **VPC routés** (``l3vni``, état ``running``) : présence et état des interfaces ``vrf-``, ``brl3-``, ``vxl3-``, ``l3--o`` et, dans le netns, ``l3--i`` ; L3VNI de type - ``L3``, ``Up``, avec la MAC de routeur attendue (``show evpn vni ``) ; route - ``unreachable default`` de métrique ``4278198272`` dans la table de la VRF. Un VPC routé créé - par une version antérieure à la 0.3.0 ne l'a pas : il est signalé à chaque tick jusqu'à sa - recréation, l'agent ne la pose pas au démarrage. + ``L3``, ``Up``, avec la MAC de routeur attendue (``show evpn vni ``). * **Réconciliation des routes exportées** dans la VRF : chaque ``/24`` de subnet ``vxlan`` et chaque ``/32`` d'interface de VM ``running`` doit être exporté ; à l'inverse, une route exportée dont le propriétaire n'existe plus — ni ``running``, ni en ``creating``, ``deleting`` ou ``error`` — diff --git a/docs/exploitation/services.rst b/docs/exploitation/services.rst index 1ae0b15..d6ff8f7 100644 --- a/docs/exploitation/services.rst +++ b/docs/exploitation/services.rst @@ -117,10 +117,6 @@ Sockets par VM /run/two/vms/monitor/.sock monitor QEMU /run/two/vms/qmp/.sock QMP (utilisé par l'agent) -QEMU les crée au démarrage et les retire en quittant normalement. La suppression d'une VM les -retire aussi, une fois QEMU arrêté : un QEMU qui échoue au démarrage (disque absent) peut les -laisser derrière lui. - .. code-block:: bash socat -,raw,echo=0 UNIX-CONNECT:/run/two/vms/serial/i-web.sock diff --git a/internal/api/agent/subnet_test.go b/internal/api/agent/subnet_test.go index b6b84a9..705a293 100644 --- a/internal/api/agent/subnet_test.go +++ b/internal/api/agent/subnet_test.go @@ -499,42 +499,3 @@ func TestGetSubnet_RelayIPOnlyForVxlan(t *testing.T) { t.Errorf("relay_ip inattendus dans la liste : %v", relays) } } - -func TestPostSubnet_DefaultRouteWithoutGatewayOnlyForBridge(t *testing.T) { - for _, req := range []SubnetCreateRequest{ - {Mode: "", CIDR: "10.0.0.0/24"}, - {Mode: "vxlan", VxlanID: 1101, CIDR: "10.0.0.0/24"}, - {Mode: "public_ip", InterfaceIP: "203.0.113.254", CIDR: "203.0.113.0/24"}, - } { - s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "running") - req.Name, req.VPC, req.DefaultRoute = "sn-1", "vpc-1", true - w := postSubnetRequest(t, s, req) - if w.Code != http.StatusBadRequest { - t.Errorf("mode %q : attendu 400, obtenu %d : %s", req.Mode, w.Code, w.Body.String()) - } - if !strings.Contains(w.Body.String(), "default_route without gateway is only allowed for bridge subnets") { - t.Errorf("mode %q : message %s", req.Mode, w.Body.String()) - } - if _, err := kv.GetFromDB(db, "subnet/sn-1/state"); err == nil { - t.Errorf("mode %q : aucun subnet ne doit être créé", req.Mode) - } - } -} - -func TestPostSubnet_DefaultRouteAccepted(t *testing.T) { - for _, req := range []SubnetCreateRequest{ - {Mode: "bridge", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24"}, - {Mode: "bridge", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", Gateway: "10.0.0.254"}, - {Mode: "", CIDR: "10.0.0.0/24", Gateway: "10.0.0.1"}, - {Mode: "vxlan", VxlanID: 1101, CIDR: "10.0.0.0/24", Gateway: "10.0.0.1"}, - {Mode: "public_ip", InterfaceIP: "203.0.113.254", CIDR: "203.0.113.0/24", Gateway: "203.0.113.1"}, - } { - s, db := newTestServer(t) - kv.AddInDB(db, "vpc/vpc-1/state", "running") - req.Name, req.VPC, req.DefaultRoute = "sn-1", "vpc-1", true - if w := postSubnetRequest(t, s, req); w.Code != http.StatusAccepted { - t.Errorf("mode %q gateway %q : attendu 202, obtenu %d : %s", req.Mode, req.Gateway, w.Code, w.Body.String()) - } - } -} diff --git a/internal/api/agent/subnets.go b/internal/api/agent/subnets.go index 64f3ac7..5390d57 100644 --- a/internal/api/agent/subnets.go +++ b/internal/api/agent/subnets.go @@ -78,11 +78,6 @@ func (s *Server) postSubnet(w http.ResponseWriter, r *http.Request) { json.NewEncoder(w).Encode(ErrorResponse{Error: "interface_ip is computed for vxlan subnets, do not set it"}) return } - if req.DefaultRoute && req.Gateway == "" && req.Mode != subnet.ModeBridge { - w.WriteHeader(http.StatusBadRequest) - json.NewEncoder(w).Encode(ErrorResponse{Error: "default_route without gateway is only allowed for bridge subnets: the host gateway is not on the subnet"}) - return - } cmd := dispatcher.CreateSubnetCommand{ Name: req.Name, VPC: req.VPC, diff --git a/internal/config/agent/config_test.go b/internal/config/agent/config_test.go index d99ec7c..a4d5b22 100644 --- a/internal/config/agent/config_test.go +++ b/internal/config/agent/config_test.go @@ -145,21 +145,4 @@ func TestLoadConfig_ExempleFourniEstValide(t *testing.T) { if cfg.QEMU.QMPDir == "" { t.Error("config.exemple.yml devrait définir qemu.qmp_dir") } - if got := cfg.PublicBridge(); got != "br-public" { - t.Errorf("config.exemple.yml : bridge public %q, br-public attendu", got) - } -} - -func TestLoadConfig_PublicBridgeWithoutInternetKey(t *testing.T) { - path := filepath.Join(t.TempDir(), "agent.yml") - if err := os.WriteFile(path, []byte("default_interface: br-000000\ninterfaces:\n lan: br-lan\n"), 0o600); err != nil { - t.Fatal(err) - } - cfg, err := LoadConfig(path) - if err != nil { - t.Fatalf("LoadConfig : %v", err) - } - if got := cfg.PublicBridge(); got != "br-public" { - t.Errorf("bridge public %q, br-public attendu (jamais default_interface)", got) - } } diff --git a/internal/config/agent/interfaces.go b/internal/config/agent/interfaces.go deleted file mode 100644 index 67e3163..0000000 --- a/internal/config/agent/interfaces.go +++ /dev/null @@ -1,13 +0,0 @@ -package configuration - -const ( - InternetInterface = "internet" - DefaultPublicBridge = "br-public" -) - -func (c Config) PublicBridge() string { - if bridge := c.Interfaces[InternetInterface]; bridge != "" { - return bridge - } - return DefaultPublicBridge -} diff --git a/internal/config/agent/interfaces_test.go b/internal/config/agent/interfaces_test.go deleted file mode 100644 index ef5a0a0..0000000 --- a/internal/config/agent/interfaces_test.go +++ /dev/null @@ -1,20 +0,0 @@ -package configuration - -import "testing" - -func TestPublicBridge(t *testing.T) { - cases := map[string]struct { - cfg Config - want string - }{ - "clé absente": {Config{DefaultInterface: "br-000000"}, "br-public"}, - "clé vide": {Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"internet": ""}}, "br-public"}, - "clé posée": {Config{Interfaces: map[string]string{"internet": "br-wan"}}, "br-wan"}, - "autres types, sans default_interface en repli": {Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"lan": "br-lan"}}, "br-public"}, - } - for name, c := range cases { - if got := c.cfg.PublicBridge(); got != c.want { - t.Errorf("%s : %q, %q attendu", name, got, c.want) - } - } -} diff --git a/internal/config/agent/struct.go b/internal/config/agent/struct.go index 3de53cb..1381d2f 100644 --- a/internal/config/agent/struct.go +++ b/internal/config/agent/struct.go @@ -24,7 +24,10 @@ type Config struct { Count int `mapstructure:"count"` BufferSize int `mapstructure:"buffer_size"` } `mapstructure:"worker"` - Times Times `mapstructure:"times"` + Dispatcher struct { + TimeoutSeconds int `mapstructure:"timeout_seconds"` + PollSeconds int `mapstructure:"poll_seconds"` + } `mapstructure:"dispatcher"` Logger struct { Level string `mapstructure:"level"` Debug bool `mapstructure:"debug"` @@ -70,13 +73,8 @@ func LoadConfig(path string) (*Config, error) { v.SetDefault("prometheus.port", 9090) v.SetDefault("worker.count", 4) v.SetDefault("worker.buffer_size", 100) - v.SetDefault("times.timeout_vms_stop", TimeoutVMsStop) - v.SetDefault("times.next_vms_shutdown", NextVMsShutdown) - v.SetDefault("times.timeout_subnet_stop", TimeoutSubnetStop) - v.SetDefault("times.timeout_vpc_stop", TimeoutVPCStop) - v.SetDefault("times.timeout_subnet_start", TimeoutSubnetStart) - v.SetDefault("times.timeout_vms_start", TimeoutVMsStart) - v.SetDefault("times.poll_interval", PollInterval) + v.SetDefault("dispatcher.timeout_seconds", 300) + v.SetDefault("dispatcher.poll_seconds", 2) v.SetDefault("metadata.run_dir", "/run/two/metadata") v.SetDefault("dhcp.backend", BackendTwo) v.SetDefault("qemu.ovmf_code_path", "/usr/share/OVMF/OVMF_CODE.fd") @@ -108,9 +106,6 @@ func LoadConfig(path string) (*Config, error) { if err := cfg.Network.Validate(); err != nil { return nil, fmt.Errorf("%s: %w", path, err) } - if err := cfg.Times.Validate(); err != nil { - return nil, fmt.Errorf("%s: %w", path, err) - } return &cfg, nil } diff --git a/internal/config/agent/times.go b/internal/config/agent/times.go deleted file mode 100644 index c482029..0000000 --- a/internal/config/agent/times.go +++ /dev/null @@ -1,64 +0,0 @@ -package configuration - -import ( - "fmt" - "time" -) - -const ( - TimeoutVMsStop = 300 - NextVMsShutdown = 30 - TimeoutSubnetStop = 360 - TimeoutVPCStop = 420 - TimeoutSubnetStart = 300 - TimeoutVMsStart = 300 - PollInterval = 2 -) - -type Times struct { - TimeoutVMsStop int `mapstructure:"timeout_vms_stop"` - NextVMsShutdown int `mapstructure:"next_vms_shutdown"` - TimeoutSubnetStop int `mapstructure:"timeout_subnet_stop"` - TimeoutVPCStop int `mapstructure:"timeout_vpc_stop"` - TimeoutSubnetStart int `mapstructure:"timeout_subnet_start"` - TimeoutVMsStart int `mapstructure:"timeout_vms_start"` - PollInterval int `mapstructure:"poll_interval"` -} - -func seconds(value, fallback int) time.Duration { - if value == 0 { - value = fallback - } - return time.Duration(value) * time.Second -} - -func (t Times) VMsStop() time.Duration { return seconds(t.TimeoutVMsStop, TimeoutVMsStop) } -func (t Times) VMsShutdown() time.Duration { return seconds(t.NextVMsShutdown, NextVMsShutdown) } -func (t Times) SubnetStop() time.Duration { return seconds(t.TimeoutSubnetStop, TimeoutSubnetStop) } -func (t Times) VPCStop() time.Duration { return seconds(t.TimeoutVPCStop, TimeoutVPCStop) } -func (t Times) SubnetStart() time.Duration { return seconds(t.TimeoutSubnetStart, TimeoutSubnetStart) } -func (t Times) VMsStart() time.Duration { return seconds(t.TimeoutVMsStart, TimeoutVMsStart) } -func (t Times) Poll() time.Duration { return seconds(t.PollInterval, PollInterval) } - -func (t Times) Validate() error { - for _, f := range []struct { - key string - value int - }{ - {"timeout_vms_stop", t.TimeoutVMsStop}, - {"next_vms_shutdown", t.NextVMsShutdown}, - {"timeout_subnet_stop", t.TimeoutSubnetStop}, - {"timeout_vpc_stop", t.TimeoutVPCStop}, - {"timeout_subnet_start", t.TimeoutSubnetStart}, - {"timeout_vms_start", t.TimeoutVMsStart}, - {"poll_interval", t.PollInterval}, - } { - if f.value <= 0 { - return fmt.Errorf("times.%s %d must be a positive number of seconds", f.key, f.value) - } - } - if t.NextVMsShutdown >= t.TimeoutVMsStop { - return fmt.Errorf("times.next_vms_shutdown %d must be below times.timeout_vms_stop %d", t.NextVMsShutdown, t.TimeoutVMsStop) - } - return nil -} diff --git a/internal/config/agent/times_test.go b/internal/config/agent/times_test.go deleted file mode 100644 index b35330c..0000000 --- a/internal/config/agent/times_test.go +++ /dev/null @@ -1,95 +0,0 @@ -package configuration - -import ( - "strings" - "testing" - "time" -) - -func TestLoadConfig_TimesDefauts(t *testing.T) { - cfg, err := LoadConfig(writeYAML(t, "")) - if err != nil { - t.Fatalf("LoadConfig a échoué : %v", err) - } - want := Times{ - TimeoutVMsStop: 300, - NextVMsShutdown: 30, - TimeoutSubnetStop: 360, - TimeoutVPCStop: 420, - TimeoutSubnetStart: 300, - TimeoutVMsStart: 300, - PollInterval: 2, - } - if cfg.Times != want { - t.Errorf("times par défaut : %+v, attendu %+v", cfg.Times, want) - } -} - -func TestLoadConfig_TimesValeursExplicites(t *testing.T) { - cfg, err := LoadConfig(writeYAML(t, "times:\n timeout_vms_stop: 600\n next_vms_shutdown: 10\n timeout_subnet_stop: 700\n timeout_vpc_stop: 800\n timeout_subnet_start: 50\n timeout_vms_start: 60\n poll_interval: 1\n")) - if err != nil { - t.Fatalf("LoadConfig a échoué : %v", err) - } - want := Times{600, 10, 700, 800, 50, 60, 1} - if cfg.Times != want { - t.Errorf("times : %+v, attendu %+v", cfg.Times, want) - } -} - -func TestLoadConfig_AncienneSectionDispatcherIgnoree(t *testing.T) { - cfg, err := LoadConfig(writeYAML(t, "dispatcher:\n timeout_seconds: 900\n poll_seconds: 7\n")) - if err != nil { - t.Fatalf("une section dispatcher restante ne doit pas empêcher le démarrage : %v", err) - } - if cfg.Times.TimeoutVMsStop != 300 || cfg.Times.PollInterval != 2 { - t.Errorf("dispatcher.* ne doit rien changer : %+v", cfg.Times) - } -} - -func TestLoadConfig_TimesInvalidesRefuses(t *testing.T) { - for _, c := range []struct{ yaml, msg string }{ - {"times:\n timeout_vms_stop: 0\n", "times.timeout_vms_stop 0 must be a positive number of seconds"}, - {"times:\n next_vms_shutdown: -1\n", "times.next_vms_shutdown -1 must be a positive number of seconds"}, - {"times:\n timeout_subnet_stop: 0\n", "times.timeout_subnet_stop 0"}, - {"times:\n timeout_vpc_stop: 0\n", "times.timeout_vpc_stop 0"}, - {"times:\n timeout_subnet_start: 0\n", "times.timeout_subnet_start 0"}, - {"times:\n timeout_vms_start: 0\n", "times.timeout_vms_start 0"}, - {"times:\n poll_interval: 0\n", "times.poll_interval 0"}, - {"times:\n next_vms_shutdown: 300\n", "times.next_vms_shutdown 300 must be below times.timeout_vms_stop 300"}, - } { - if _, err := LoadConfig(writeYAML(t, c.yaml)); err == nil || !strings.Contains(err.Error(), c.msg) { - t.Errorf("%q : erreur %v, attendu %q", c.yaml, err, c.msg) - } - } - if _, err := LoadConfig(writeYAML(t, "times:\n next_vms_shutdown: 299\n")); err != nil { - t.Errorf("next_vms_shutdown 299 sous timeout_vms_stop 300 : %v", err) - } -} - -func TestTimesDurees(t *testing.T) { - var zero Times - cases := []struct { - name string - got, want time.Duration - }{ - {"VMsStop", zero.VMsStop(), 300 * time.Second}, - {"VMsShutdown", zero.VMsShutdown(), 30 * time.Second}, - {"SubnetStop", zero.SubnetStop(), 360 * time.Second}, - {"VPCStop", zero.VPCStop(), 420 * time.Second}, - {"SubnetStart", zero.SubnetStart(), 300 * time.Second}, - {"VMsStart", zero.VMsStart(), 300 * time.Second}, - {"Poll", zero.Poll(), 2 * time.Second}, - } - for _, c := range cases { - if c.got != c.want { - t.Errorf("Times{}.%s() = %v, attendu %v", c.name, c.got, c.want) - } - } - set := Times{11, 12, 13, 14, 15, 16, 17} - got := []time.Duration{set.VMsStop(), set.VMsShutdown(), set.SubnetStop(), set.VPCStop(), set.SubnetStart(), set.VMsStart(), set.Poll()} - for i, d := range got { - if want := time.Duration(11+i) * time.Second; d != want { - t.Errorf("durée %d = %v, attendu %v", i, d, want) - } - } -} diff --git a/internal/dispatcher/agent/subnet_commands.go b/internal/dispatcher/agent/subnet_commands.go index 91f08bc..d97de05 100644 --- a/internal/dispatcher/agent/subnet_commands.go +++ b/internal/dispatcher/agent/subnet_commands.go @@ -1,7 +1,6 @@ package dispatcher import ( - "errors" "fmt" "sort" "strconv" @@ -94,21 +93,23 @@ func (c CreateSubnetCommand) Prepare(db *badger.DB, cfg *configuration.Config) e } func (c CreateSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error { - err := waitUntil(cfg.Times.SubnetStart(), cfg.Times.Poll(), func() (bool, error) { + timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second) + for { vpcState, err := state.Get(db, "vpc/"+c.VPC) if err != nil { - return false, fmt.Errorf("vpc %q not found while waiting", c.VPC) + return fmt.Errorf("vpc %q not found while waiting", c.VPC) } - if vpcState != state.Running && vpcState != state.Creating { - return false, fmt.Errorf("vpc %q is %s, cannot create subnet %q", c.VPC, vpcState, c.Name) + if vpcState == state.Running { + break + } + if vpcState != state.Creating { + return fmt.Errorf("vpc %q is %s, cannot create subnet %q", c.VPC, vpcState, c.Name) + } + select { + case <-timeout: + return fmt.Errorf("timed out waiting for vpc %q to be running", c.VPC) + case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second): } - return vpcState == state.Running, nil - }) - if errors.Is(err, errWaitTimeout) { - return fmt.Errorf("timed out waiting for vpc %q to be running", c.VPC) - } - if err != nil { - return err } return subnet.CreateSubnet(db, c.Name, cfg) } @@ -131,41 +132,12 @@ func (c DeleteSubnetCommand) Prepare(db *badger.DB, _ *configuration.Config) err if err != nil { return err } - var blocking []string - for _, name := range vms { - if s, err := state.Get(db, "vm/"+name); err != nil || s != state.Deleting { - blocking = append(blocking, name) - } - } - if len(blocking) > 0 { - return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(blocking, ", ")) + if len(vms) > 0 { + return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(vms, ", ")) } return state.Set(db, c.Key(), state.Deleting) } -func waitVMsDeleted(db *badger.DB, subnetName string, timeout, poll time.Duration) error { - err := waitUntil(timeout, poll, func() (bool, error) { - vms, err := vmsUsingSubnet(db, subnetName) - if err != nil { - return false, err - } - for _, name := range vms { - s, err := state.Get(db, "vm/"+name) - if err != nil { - continue - } - if s != state.Deleting { - return false, fmt.Errorf("vm %q is %s, subnet %q cannot be deleted", name, s, subnetName) - } - } - return len(vms) == 0, nil - }) - if errors.Is(err, errWaitTimeout) { - return fmt.Errorf("timed out waiting for the vms of subnet %q to be deleted", subnetName) - } - return err -} - func vmsUsingSubnet(db *badger.DB, subnetName string) ([]string, error) { entries, err := kv.ListByPrefix(db, "vm/") if err != nil { @@ -187,9 +159,6 @@ func vmsUsingSubnet(db *badger.DB, subnetName string) ([]string, error) { } func (c DeleteSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error { - if err := waitVMsDeleted(db, c.Name, cfg.Times.SubnetStop(), cfg.Times.Poll()); err != nil { - return err - } if err := subnet.DeleteSubnet(db, c.Name, cfg); err != nil { return err } diff --git a/internal/dispatcher/agent/subnet_commands_test.go b/internal/dispatcher/agent/subnet_commands_test.go index a2d6cd5..d9095f2 100644 --- a/internal/dispatcher/agent/subnet_commands_test.go +++ b/internal/dispatcher/agent/subnet_commands_test.go @@ -418,7 +418,7 @@ func TestDeleteSubnetCommand_Prepare_RefusedWhileAVMUsesIt(t *testing.T) { kv.AddInDB(db, "vm/i-c/state", "running") kv.AddInDB(db, "vm/i-c/nic/0/subnet", "sn-a") err := DeleteSubnetCommand{Name: "sn-a"}.Prepare(db, nil) - if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-c`) { + if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-b, i-c`) { t.Fatalf("erreur %v", err) } if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "running" { diff --git a/internal/dispatcher/agent/vm_commands.go b/internal/dispatcher/agent/vm_commands.go index bcd8b61..3bdd7ee 100644 --- a/internal/dispatcher/agent/vm_commands.go +++ b/internal/dispatcher/agent/vm_commands.go @@ -1,7 +1,6 @@ package dispatcher import ( - "errors" "fmt" "math/rand" "strconv" @@ -152,23 +151,24 @@ func allocateMetadataPort(db *badger.DB) (int, error) { } func (c StartVMCommand) Execute(db *badger.DB, cfg *configuration.Config) error { - timeout := time.Now().Add(cfg.Times.VMsStart()) + timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second) for _, n := range c.NICs { - err := waitUntil(time.Until(timeout), cfg.Times.Poll(), func() (bool, error) { + for { subnetState, err := state.Get(db, "subnet/"+n.Subnet) if err != nil { - return false, fmt.Errorf("subnet %q not found while waiting", n.Subnet) + return fmt.Errorf("subnet %q not found while waiting", n.Subnet) } - if subnetState != state.Running && subnetState != state.Creating { - return false, fmt.Errorf("subnet %q is %s, cannot start vm %q", n.Subnet, subnetState, c.Name) + if subnetState == state.Running { + break + } + if subnetState != state.Creating { + return fmt.Errorf("subnet %q is %s, cannot start vm %q", n.Subnet, subnetState, c.Name) + } + select { + case <-timeout: + return fmt.Errorf("timed out waiting for subnet %q to be running", n.Subnet) + case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second): } - return subnetState == state.Running, nil - }) - if errors.Is(err, errWaitTimeout) { - return fmt.Errorf("timed out waiting for subnet %q to be running", n.Subnet) - } - if err != nil { - return err } } return vm.StartVM(db, c.Name, cfg) diff --git a/internal/dispatcher/agent/vpc_commands.go b/internal/dispatcher/agent/vpc_commands.go index 7e73164..df87004 100644 --- a/internal/dispatcher/agent/vpc_commands.go +++ b/internal/dispatcher/agent/vpc_commands.go @@ -1,7 +1,6 @@ package dispatcher import ( - "errors" "fmt" "net" "strconv" @@ -130,8 +129,31 @@ func (c DeleteVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error } func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) error { - if err := waitSubnetsDeleted(db, c.Name, cfg.Times.VPCStop(), cfg.Times.Poll()); err != nil { - return err + timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second) + for { + entries, err := kv.ListByPrefix(db, "subnet/") + if err != nil { + return fmt.Errorf("failed to list subnets: %w", err) + } + pending := false + for key, value := range entries { + if strings.HasSuffix(key, "/vpc") && value == c.Name { + subnetName := strings.Split(key, "/")[1] + s, _ := state.Get(db, "subnet/"+subnetName) + if s == state.Deleting { + pending = true + break + } + } + } + if !pending { + break + } + select { + case <-timeout: + return fmt.Errorf("timed out waiting for subnets of vpc %q to be deleted", c.Name) + case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second): + } } if err := vpc.DeleteVPC(db, c.Name); err != nil { return err @@ -145,35 +167,3 @@ func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) erro } return nil } - -func waitSubnetsDeleted(db *badger.DB, vpcName string, timeout, poll time.Duration) error { - err := waitUntil(timeout, poll, func() (bool, error) { - entries, err := kv.ListByPrefix(db, "subnet/") - if err != nil { - return false, fmt.Errorf("failed to list subnets: %w", err) - } - pending := false - for key, value := range entries { - if !strings.HasSuffix(key, "/vpc") || value != vpcName { - continue - } - subnetName := strings.Split(key, "/")[1] - s, err := state.Get(db, "subnet/"+subnetName) - if err != nil { - continue - } - switch s { - case state.Deleted: - case state.Deleting: - pending = true - default: - return false, fmt.Errorf("subnet %q is %s, vpc %q cannot be deleted", subnetName, s, vpcName) - } - } - return !pending, nil - }) - if errors.Is(err, errWaitTimeout) { - return fmt.Errorf("timed out waiting for subnets of vpc %q to be deleted", vpcName) - } - return err -} diff --git a/internal/dispatcher/agent/wait.go b/internal/dispatcher/agent/wait.go deleted file mode 100644 index 2274f33..0000000 --- a/internal/dispatcher/agent/wait.go +++ /dev/null @@ -1,26 +0,0 @@ -package dispatcher - -import ( - "errors" - "time" -) - -var errWaitTimeout = errors.New("timed out") - -func waitUntil(timeout, poll time.Duration, done func() (bool, error)) error { - deadline := time.After(timeout) - for { - ok, err := done() - if err != nil { - return err - } - if ok { - return nil - } - select { - case <-deadline: - return errWaitTimeout - case <-time.After(poll): - } - } -} diff --git a/internal/dispatcher/agent/wait_test.go b/internal/dispatcher/agent/wait_test.go deleted file mode 100644 index f3dd7cb..0000000 --- a/internal/dispatcher/agent/wait_test.go +++ /dev/null @@ -1,168 +0,0 @@ -package dispatcher - -import ( - "errors" - "strings" - "testing" - "time" - - configuration "git.g3e.fr/syonad/two/internal/config/agent" - "git.g3e.fr/syonad/two/pkg/db/kv" -) - -func TestWaitUntil(t *testing.T) { - calls := 0 - err := waitUntil(time.Second, time.Millisecond, func() (bool, error) { - calls++ - return calls == 3, nil - }) - if err != nil || calls != 3 { - t.Errorf("err %v, %d appels, attendu fin au troisième", err, calls) - } - - if err := waitUntil(30*time.Millisecond, 5*time.Millisecond, func() (bool, error) { return false, nil }); !errors.Is(err, errWaitTimeout) { - t.Errorf("délai dépassé : %v", err) - } - - boom := errors.New("boom") - calls = 0 - err = waitUntil(time.Second, time.Millisecond, func() (bool, error) { - calls++ - return false, boom - }) - if !errors.Is(err, boom) || calls != 1 { - t.Errorf("erreur %v après %d appels, attendu boom au premier", err, calls) - } -} - -func TestDeleteSubnetCommand_Prepare_AcceptsVMsBeingDeleted(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-a/state", "running") - kv.AddInDB(db, "vm/i-a/state", "deleting") - kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") - kv.AddInDB(db, "vm/i-gone/state", "deleted") - kv.AddInDB(db, "vm/i-gone/nic/0/subnet", "sn-a") - if err := (DeleteSubnetCommand{Name: "sn-a"}).Prepare(db, nil); err != nil { - t.Fatalf("VM en deleting : %v", err) - } - if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "deleting" { - t.Errorf("état %q, attendu deleting", s) - } -} - -func TestDeleteSubnetCommand_Prepare_ListsOnlyTheVMsNotBeingDeleted(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-a/state", "running") - kv.AddInDB(db, "vm/i-a/state", "deleting") - kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") - kv.AddInDB(db, "vm/i-b/state", "running") - kv.AddInDB(db, "vm/i-b/nic/0/subnet", "sn-a") - err := DeleteSubnetCommand{Name: "sn-a"}.Prepare(db, nil) - if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-b`) || strings.Contains(err.Error(), "i-a") { - t.Fatalf("erreur %v", err) - } -} - -func TestWaitVMsDeleted_ReturnsOnceTheVMsAreGone(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "vm/i-a/state", "deleting") - kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") - kv.AddInDB(db, "vm/i-other/state", "running") - kv.AddInDB(db, "vm/i-other/nic/0/subnet", "sn-b") - go func() { - time.Sleep(30 * time.Millisecond) - kv.DeleteInDB(db, "vm/i-a") - }() - if err := waitVMsDeleted(db, "sn-a", 2*time.Second, 5*time.Millisecond); err != nil { - t.Fatalf("attente : %v", err) - } -} - -func TestWaitVMsDeleted_FailsWhenAVMEndsInError(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "vm/i-a/state", "deleting") - kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") - go func() { - time.Sleep(20 * time.Millisecond) - kv.AddInDB(db, "vm/i-a/state", "error") - }() - err := waitVMsDeleted(db, "sn-a", 2*time.Second, 5*time.Millisecond) - if err == nil || !strings.Contains(err.Error(), `vm "i-a" is error, subnet "sn-a" cannot be deleted`) { - t.Fatalf("erreur %v", err) - } -} - -func TestWaitVMsDeleted_TimesOut(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "vm/i-a/state", "deleting") - kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") - err := waitVMsDeleted(db, "sn-a", 30*time.Millisecond, 5*time.Millisecond) - if err == nil || err.Error() != `timed out waiting for the vms of subnet "sn-a" to be deleted` { - t.Fatalf("erreur %v", err) - } -} - -func TestWaitSubnetsDeleted_ReturnsOnceTheSubnetsAreGone(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-a/state", "deleting") - kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a") - kv.AddInDB(db, "subnet/sn-b/state", "deleted") - kv.AddInDB(db, "subnet/sn-b/vpc", "vp-a") - kv.AddInDB(db, "subnet/sn-x/state", "running") - kv.AddInDB(db, "subnet/sn-x/vpc", "vp-x") - go func() { - time.Sleep(30 * time.Millisecond) - kv.DeleteInDB(db, "subnet/sn-a") - }() - if err := waitSubnetsDeleted(db, "vp-a", 2*time.Second, 5*time.Millisecond); err != nil { - t.Fatalf("attente : %v", err) - } -} - -func TestWaitSubnetsDeleted_FailsWhenASubnetEndsInError(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-a/state", "deleting") - kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a") - go func() { - time.Sleep(20 * time.Millisecond) - kv.AddInDB(db, "subnet/sn-a/state", "error") - }() - err := waitSubnetsDeleted(db, "vp-a", 2*time.Second, 5*time.Millisecond) - if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is error, vpc "vp-a" cannot be deleted`) { - t.Fatalf("erreur %v", err) - } -} - -func TestWaitSubnetsDeleted_TimesOut(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-a/state", "deleting") - kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a") - err := waitSubnetsDeleted(db, "vp-a", 30*time.Millisecond, 5*time.Millisecond) - if err == nil || err.Error() != `timed out waiting for subnets of vpc "vp-a" to be deleted` { - t.Fatalf("erreur %v", err) - } -} - -func TestDeleteSubnetCommand_Execute_FailsBeforeTouchingTheHostWhenAVMIsInError(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "subnet/sn-a/state", "deleting") - kv.AddInDB(db, "vm/i-a/state", "error") - kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") - cfg := &configuration.Config{Times: configuration.Times{TimeoutSubnetStop: 1, PollInterval: 1}} - err := DeleteSubnetCommand{Name: "sn-a"}.Execute(db, cfg) - if err == nil || err.Error() != `vm "i-a" is error, subnet "sn-a" cannot be deleted` { - t.Fatalf("erreur %v", err) - } -} - -func TestDeleteVPCCommand_Execute_FailsBeforeTouchingTheHostWhenASubnetIsInError(t *testing.T) { - _, db := newTestDispatcher(t) - kv.AddInDB(db, "vpc/vp-a/state", "deleting") - kv.AddInDB(db, "subnet/sn-a/state", "error") - kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a") - cfg := &configuration.Config{Times: configuration.Times{TimeoutVPCStop: 1, PollInterval: 1}} - err := DeleteVPCCommand{Name: "vp-a"}.Execute(db, cfg) - if err == nil || err.Error() != `subnet "sn-a" is error, vpc "vp-a" cannot be deleted` { - t.Fatalf("erreur %v", err) - } -} diff --git a/internal/l3vni/host.go b/internal/l3vni/host.go index 24a6c98..4899d3e 100644 --- a/internal/l3vni/host.go +++ b/internal/l3vni/host.go @@ -23,8 +23,6 @@ type host interface { DeleteLink(name string) error TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error TableRouteDel(table uint32, dst *net.IPNet) error - TableUnreachableDefault(table uint32) error - TableUnreachableDefaultDel(table uint32) error ApplyVRF(v frr.VRF) error WithdrawVRF(v frr.VRF) error RemoveVRF(v frr.VRF) error @@ -89,14 +87,6 @@ func (system) TableRouteDel(table uint32, dst *net.IPNet) error { return netif.RouteDelIfExists(int(table), dst) } -func (system) TableUnreachableDefault(table uint32) error { - return netif.RouteReplaceUnreachableDefault(int(table), UnreachableMetric) -} - -func (system) TableUnreachableDefaultDel(table uint32) error { - return netif.RouteDelUnreachableDefaultIfExists(int(table), UnreachableMetric) -} - func (s system) ApplyVRF(v frr.VRF) error { return s.frr.ApplyVRF(v) } func (s system) WithdrawVRF(v frr.VRF) error { return s.frr.WithdrawVRF(v) } diff --git a/internal/l3vni/l3.go b/internal/l3vni/l3.go index ad22ac2..65bd453 100644 --- a/internal/l3vni/l3.go +++ b/internal/l3vni/l3.go @@ -14,8 +14,6 @@ import ( "github.com/dgraph-io/badger/v4" ) -const UnreachableMetric = 4278198272 - var ( transitHost = &net.IPNet{IP: net.IPv4(169, 254, 0, 1).To4(), Mask: net.CIDRMask(30, 32)} transitNetns = &net.IPNet{IP: net.IPv4(169, 254, 0, 2).To4(), Mask: net.CIDRMask(30, 32)} @@ -86,7 +84,6 @@ func createL3(h host, cfg *configuration.Config, v l3VPC) error { run func() error }{ {"create " + v.vrf(), func() error { return h.CreateVRF(v.vrf(), v.vni) }}, - {"unreachable default in " + v.vrf(), func() error { return h.TableUnreachableDefault(v.vni) }}, {"create " + v.bridge(), func() error { return h.CreateBridge(v.bridge(), mtu, rmac) }}, {"attach " + v.bridge(), func() error { return h.SetMaster(v.bridge(), v.vrf()) }}, {"create " + v.vxlan(), func() error { return h.CreateVxlan(v.vxlan(), int(v.vni), cfg.DefaultInterface, mtu) }}, @@ -126,9 +123,6 @@ func deleteL3(h host, v l3VPC) error { return fmt.Errorf("l3vni %d: delete %s: %w", v.vni, link, err) } } - if err := h.TableUnreachableDefaultDel(v.vni); err != nil { - return fmt.Errorf("l3vni %d: delete unreachable default from table %d: %w", v.vni, v.vni, err) - } if err := h.RemoveVRF(frrVRF); err != nil { return fmt.Errorf("l3vni %d: remove frr vrf: %w", v.vni, err) } diff --git a/internal/l3vni/l3_test.go b/internal/l3vni/l3_test.go index 7855f27..17e0c8c 100644 --- a/internal/l3vni/l3_test.go +++ b/internal/l3vni/l3_test.go @@ -83,14 +83,6 @@ func (f *fakeHost) TableRouteDel(table uint32, dst *net.IPNet) error { return f.record(fmt.Sprintf("table %d del %s", table, dst)) } -func (f *fakeHost) TableUnreachableDefault(table uint32) error { - return f.record(fmt.Sprintf("table %d unreachable default", table)) -} - -func (f *fakeHost) TableUnreachableDefaultDel(table uint32) error { - return f.record(fmt.Sprintf("table %d del unreachable default", table)) -} - func (f *fakeHost) ApplyVRF(v frr.VRF) error { return f.record(fmt.Sprintf("frr apply asn=%d id=%s vni=%d vtep=%s supernet=%s", v.ASN, v.ID, v.L3VNI, v.VTEP, v.Supernet)) } @@ -129,7 +121,6 @@ func TestCreateL3FollowsTheLabRecipe(t *testing.T) { want := []string{ "vtep br-000000", "vrf vrf-s7 table 2700", - "table 2700 unreachable default", "bridge brl3-s7 mtu 1450 mac 02:02:c0:a8:0e:0b", "master brl3-s7 vrf-s7", "vxlan vxl3-s7 id 2700 dev br-000000 mtu 1450", @@ -188,7 +179,6 @@ func TestDeleteL3WithdrawsFRRThenTheKernelThenTheVRF(t *testing.T) { "del vxl3-s7", "del brl3-s7", "del vrf-s7", - "table 2700 del unreachable default", "frr remove asn=0 id=s7 vni=0", } if !reflect.DeepEqual(f.calls, want) { @@ -219,39 +209,9 @@ func TestDeleteL3KeepsTheFRRVRFWhenAKernelLinkCannotBeDeleted(t *testing.T) { } } -func TestCreateL3LeavesNoVRFWithoutItsUnreachableDefault(t *testing.T) { - f := &fakeHost{fail: map[string]error{"table 2700 unreachable default": errors.New("operation not permitted")}} - err := createL3(f, bgpConfig(), labL3(t)) - if err == nil || !strings.Contains(err.Error(), "l3vni 2700: unreachable default in vrf-s7: operation not permitted") { - t.Errorf("erreur %v", err) - } - if last := f.calls[len(f.calls)-1]; last != "table 2700 unreachable default" { - t.Errorf("appels après l'échec : %q", f.calls) - } -} - -func TestDeleteL3KeepsTheFRRVRFWhenTheUnreachableDefaultCannotBeDeleted(t *testing.T) { - f := &fakeHost{fail: map[string]error{"table 2700 del unreachable default": errors.New("operation not permitted")}} - err := deleteL3(f, labL3(t)) - if err == nil || !strings.Contains(err.Error(), "delete unreachable default from table 2700") { - t.Errorf("erreur %v", err) - } - for _, c := range f.calls { - if strings.HasPrefix(c, "frr remove") { - t.Errorf("étape exécutée après l'échec : %q", f.calls) - } - } -} - -func TestUnreachableMetricIsTheHighestRecommendedByTheKernel(t *testing.T) { - if UnreachableMetric != 4278198272 { - t.Errorf("UnreachableMetric = %d", UnreachableMetric) - } -} - func TestDeleteL3DoesNotDependOnTheAgentBGPSection(t *testing.T) { f := &fakeHost{} - if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 7 { + if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 6 { t.Errorf("erreur %v, appels %q", err, f.calls) } } diff --git a/internal/netif/link.go b/internal/netif/link.go index 8c4b2b0..56fdb87 100644 --- a/internal/netif/link.go +++ b/internal/netif/link.go @@ -46,21 +46,3 @@ func LinkMTU(name string) (int, error) { } return link.Attrs().MTU, nil } - -func BridgeVxlanPorts(bridge string) ([]string, error) { - br, err := netlink.LinkByName(bridge) - if err != nil { - return nil, err - } - links, err := netlink.LinkList() - if err != nil { - return nil, err - } - var ports []string - for _, l := range links { - if l.Attrs().MasterIndex == br.Attrs().Index && l.Type() == "vxlan" { - ports = append(ports, l.Attrs().Name) - } - } - return ports, nil -} diff --git a/internal/netif/route_linux.go b/internal/netif/route_linux.go index 1001a53..a7be050 100644 --- a/internal/netif/route_linux.go +++ b/internal/netif/route_linux.go @@ -3,16 +3,11 @@ package netif import ( - "errors" "net" - "syscall" "github.com/vishvananda/netlink" - "golang.org/x/sys/unix" ) -var defaultIPv4 = &net.IPNet{IP: net.IPv4zero.To4(), Mask: net.CIDRMask(0, 32)} - func RouteAdd(iface string, subnet *net.IPNet) error { return RouteAddFrom(iface, subnet, nil) } @@ -50,44 +45,3 @@ func TableRoutesVia(table int, iface string) ([]*net.IPNet, error) { } return dsts, nil } - -func unreachableDefault(table, metric int) *netlink.Route { - return &netlink.Route{ - Dst: defaultIPv4, - Table: table, - Type: unix.RTN_UNREACHABLE, - Priority: metric, - } -} - -func RouteReplaceUnreachableDefault(table, metric int) error { - return netlink.RouteReplace(unreachableDefault(table, metric)) -} - -func RouteDelUnreachableDefaultIfExists(table, metric int) error { - if err := netlink.RouteDel(unreachableDefault(table, metric)); err != nil && !errors.Is(err, syscall.ESRCH) { - return err - } - return nil -} - -func HasUnreachableDefault(table, metric int) (bool, error) { - routes, err := netlink.RouteListFiltered(netlink.FAMILY_V4, &netlink.Route{ - Table: table, - Type: unix.RTN_UNREACHABLE, - }, netlink.RT_FILTER_TABLE|netlink.RT_FILTER_TYPE) - if err != nil { - return false, err - } - for _, r := range routes { - if r.Priority == metric && (r.Dst == nil || isDefault(r.Dst)) { - return true, nil - } - } - return false, nil -} - -func isDefault(dst *net.IPNet) bool { - ones, _ := dst.Mask.Size() - return ones == 0 -} diff --git a/internal/netif/route_other.go b/internal/netif/route_other.go index 9b7a12b..d87bf82 100644 --- a/internal/netif/route_other.go +++ b/internal/netif/route_other.go @@ -18,15 +18,3 @@ func RouteAddFrom(_ string, _ *net.IPNet, _ net.IP) error { func TableRoutesVia(_ int, _ string) ([]*net.IPNet, error) { return nil, errors.New("route listing is only implemented on linux") } - -func RouteReplaceUnreachableDefault(_, _ int) error { - return errors.New("not supported on this platform") -} - -func RouteDelUnreachableDefaultIfExists(_, _ int) error { - return errors.New("not supported on this platform") -} - -func HasUnreachableDefault(_, _ int) (bool, error) { - return false, errors.New("route listing is only implemented on linux") -} diff --git a/internal/vm/delete.go b/internal/vm/delete.go index be87a2a..304a75d 100644 --- a/internal/vm/delete.go +++ b/internal/vm/delete.go @@ -1,10 +1,7 @@ package vm import ( - "encoding/json" - "errors" "fmt" - "io/fs" "os" "path/filepath" "time" @@ -50,14 +47,16 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { if _, err := os.Stat(socketPath); err == nil { // socket présent : tenter l'arrêt gracieux - shutdownQEMU(qmp.Send, socketPath, cfg.Times.VMsStop(), cfg.Times.VMsShutdown(), cfg.Times.Poll()) + if _, err := qmp.Send(socketPath, []string{`{"execute":"system_powerdown"}`}); err == nil { + waitQMPDead(socketPath, + time.Duration(cfg.Dispatcher.TimeoutSeconds)*time.Second, + time.Duration(cfg.Dispatcher.PollSeconds)*time.Second, + ) + } + // connexion QMP échouée : QEMU déjà mort } // socket absent ou QEMU déjà arrêté : cleanup direct - if err := removeQEMUSockets(cfg, name); err != nil { - return err - } - if err := netns.Call(nic.vpcName, func() error { for _, n := range d.nics { if err := iptables.DeleteMetadataRedirect(n.ip, nic.interfaceIP, d.metadataPort); err != nil { @@ -91,16 +90,6 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { return state.Set(db, "vm/"+name, state.Deleted) } -func removeQEMUSockets(cfg *configuration.Config, name string) error { - for _, dir := range []string{cfg.QEMU.SerialDir, cfg.QEMU.MonitorDir, cfg.QEMU.QMPDir} { - path := filepath.Join(dir, name+".sock") - if err := os.Remove(path); err != nil && !errors.Is(err, fs.ErrNotExist) { - return fmt.Errorf("remove qemu socket: %w", err) - } - } - return nil -} - func removeDHCPFiles(d vmData, name string, backend dhcpbackend.Backend) error { for _, f := range dhcpReservations(d) { if err := backend.DelVM(f.subnet, name, f.reservations); err != nil { @@ -110,31 +99,15 @@ func removeDHCPFiles(d vmData, name string, backend dhcpbackend.Backend) error { return nil } -type qmpSender func(socketPath string, commands []string) ([]json.RawMessage, error) - -const ( - qmpPowerdown = `{"execute":"system_powerdown"}` - qmpQuit = `{"execute":"quit"}` -) - -func shutdownQEMU(send qmpSender, socketPath string, timeout, resend, poll time.Duration) { - if _, err := send(socketPath, []string{qmpPowerdown}); err != nil { - return - } - deadline := time.After(timeout) - again := time.NewTicker(resend) - defer again.Stop() +func waitQMPDead(socketPath string, timeout, poll time.Duration) { + timer := time.After(timeout) for { select { - case <-deadline: - send(socketPath, []string{qmpQuit}) + case <-timer: + qmp.Send(socketPath, []string{`{"execute":"quit"}`}) return - case <-again.C: - if _, err := send(socketPath, []string{qmpPowerdown}); err != nil { - return - } case <-time.After(poll): - if _, err := send(socketPath, nil); err != nil { + if _, err := qmp.Send(socketPath, nil); err != nil { return } } diff --git a/internal/vm/delete_test.go b/internal/vm/delete_test.go deleted file mode 100644 index d296f68..0000000 --- a/internal/vm/delete_test.go +++ /dev/null @@ -1,86 +0,0 @@ -package vm - -import ( - "os" - "path/filepath" - "strings" - "testing" - - configuration "git.g3e.fr/syonad/two/internal/config/agent" -) - -func socketDirs(t *testing.T) *configuration.Config { - t.Helper() - root, err := os.MkdirTemp("", "sock") - if err != nil { - t.Fatal(err) - } - t.Cleanup(func() { os.RemoveAll(root) }) - cfg := &configuration.Config{} - cfg.QEMU.SerialDir = filepath.Join(root, "serial") - cfg.QEMU.MonitorDir = filepath.Join(root, "monitor") - cfg.QEMU.QMPDir = filepath.Join(root, "qmp") - for _, dir := range []string{cfg.QEMU.SerialDir, cfg.QEMU.MonitorDir, cfg.QEMU.QMPDir} { - if err := os.Mkdir(dir, 0755); err != nil { - t.Fatal(err) - } - } - return cfg -} - -func leave(t *testing.T, path string) { - t.Helper() - if err := os.WriteFile(path, nil, 0600); err != nil { - t.Fatal(err) - } -} - -func TestRemoveQEMUSockets_RemovesTheThreeSocketsOfTheVM(t *testing.T) { - cfg := socketDirs(t) - sockets := []string{ - filepath.Join(cfg.QEMU.SerialDir, "t12-err.sock"), - filepath.Join(cfg.QEMU.MonitorDir, "t12-err.sock"), - filepath.Join(cfg.QEMU.QMPDir, "t12-err.sock"), - } - for _, s := range sockets { - leave(t, s) - } - other := filepath.Join(cfg.QEMU.MonitorDir, "t12-ok.sock") - leave(t, other) - - if err := removeQEMUSockets(cfg, "t12-err"); err != nil { - t.Fatal(err) - } - for _, s := range sockets { - if _, err := os.Lstat(s); !os.IsNotExist(err) { - t.Errorf("%s laissé (%v)", s, err) - } - } - if _, err := os.Lstat(other); err != nil { - t.Errorf("socket d'une autre VM retiré : %v", err) - } -} - -func TestRemoveQEMUSockets_AbsentSocketsAreNotAnError(t *testing.T) { - cfg := socketDirs(t) - leave(t, filepath.Join(cfg.QEMU.MonitorDir, "t12-err.sock")) - if err := removeQEMUSockets(cfg, "t12-err"); err != nil { - t.Errorf("sockets serial et qmp absents : %v", err) - } - if err := removeQEMUSockets(cfg, "t12-err"); err != nil { - t.Errorf("second passage : %v", err) - } -} - -func TestRemoveQEMUSockets_ReportsAFailedRemoval(t *testing.T) { - cfg := socketDirs(t) - blocked := filepath.Join(cfg.QEMU.QMPDir, "t12-err.sock") - if err := os.Mkdir(blocked, 0755); err != nil { - t.Fatal(err) - } - leave(t, filepath.Join(blocked, "x")) - err := removeQEMUSockets(cfg, "t12-err") - if err == nil || !strings.Contains(err.Error(), "remove qemu socket") || !strings.Contains(err.Error(), blocked) { - t.Errorf("erreur %v, attendu l'échec de suppression de %s", err, blocked) - } -} diff --git a/internal/vm/shutdown_test.go b/internal/vm/shutdown_test.go deleted file mode 100644 index 1e5cd6c..0000000 --- a/internal/vm/shutdown_test.go +++ /dev/null @@ -1,102 +0,0 @@ -package vm - -import ( - "encoding/json" - "errors" - "sync" - "testing" - "time" -) - -type fakeQEMU struct { - mu sync.Mutex - calls []string - dieAfter int - powerdown int - dead bool -} - -func (f *fakeQEMU) send(_ string, commands []string) ([]json.RawMessage, error) { - f.mu.Lock() - defer f.mu.Unlock() - call := "ping" - if len(commands) > 0 { - call = commands[0] - } - f.calls = append(f.calls, call) - if f.dead { - return nil, errors.New("qmp dial: connection refused") - } - switch call { - case qmpPowerdown: - f.powerdown++ - if f.dieAfter > 0 && f.powerdown >= f.dieAfter { - f.dead = true - } - case qmpQuit: - f.dead = true - } - return nil, nil -} - -func (f *fakeQEMU) count(call string) int { - f.mu.Lock() - defer f.mu.Unlock() - n := 0 - for _, c := range f.calls { - if c == call { - n++ - } - } - return n -} - -func TestShutdownQEMU_ResendsPowerdownUntilTheGuestListens(t *testing.T) { - f := &fakeQEMU{dieAfter: 3} - start := time.Now() - shutdownQEMU(f.send, "qmp.sock", 5*time.Second, 50*time.Millisecond, 10*time.Millisecond) - if d := time.Since(start); d > 2*time.Second { - t.Errorf("arrêt en %v : le renvoi aurait dû l'obtenir bien avant le délai", d) - } - if n := f.count(qmpPowerdown); n != 3 { - t.Errorf("%d system_powerdown envoyés, attendu 3 (le troisième est entendu)", n) - } - if n := f.count(qmpQuit); n != 0 { - t.Errorf("quit envoyé alors que l'invité s'est arrêté : %q", f.calls) - } -} - -func TestShutdownQEMU_QuitsAtTheDeadline(t *testing.T) { - f := &fakeQEMU{} - start := time.Now() - shutdownQEMU(f.send, "qmp.sock", 200*time.Millisecond, 60*time.Millisecond, 10*time.Millisecond) - d := time.Since(start) - if d < 200*time.Millisecond || d > 2*time.Second { - t.Errorf("arrêt en %v, attendu au délai de 200ms", d) - } - if n := f.count(qmpPowerdown); n < 3 { - t.Errorf("%d system_powerdown envoyés en 200ms avec un renvoi toutes les 60ms", n) - } - if n := f.count(qmpQuit); n != 1 { - t.Errorf("%d quit envoyés, attendu 1 : %q", n, f.calls) - } -} - -func TestShutdownQEMU_StopsWhenTheGuestShutsDownOnItsOwn(t *testing.T) { - f := &fakeQEMU{dieAfter: 1} - shutdownQEMU(f.send, "qmp.sock", 5*time.Second, time.Second, 10*time.Millisecond) - if n := f.count(qmpPowerdown); n != 1 { - t.Errorf("%d system_powerdown envoyés, attendu 1", n) - } - if n := f.count(qmpQuit); n != 0 { - t.Errorf("quit envoyé : %q", f.calls) - } -} - -func TestShutdownQEMU_NothingMoreWhenQEMUIsAlreadyDead(t *testing.T) { - f := &fakeQEMU{dead: true} - shutdownQEMU(f.send, "qmp.sock", 5*time.Second, time.Second, 10*time.Millisecond) - if len(f.calls) != 1 { - t.Errorf("appels QMP : %q, attendu un seul essai", f.calls) - } -} diff --git a/internal/vpc/create.go b/internal/vpc/create.go index 8b31911..c0377bf 100644 --- a/internal/vpc/create.go +++ b/internal/vpc/create.go @@ -32,7 +32,7 @@ func CreateVPC(db *badger.DB, name string, cfg *configuration.Config) error { return err } - if err := netif.BridgeSetMaster("vp-"+vpcID+"-e", cfg.PublicBridge()); err != nil { + if err := netif.BridgeSetMaster("vp-"+vpcID+"-e", "br-public"); err != nil { return err } diff --git a/internal/watchdog/check_l3.go b/internal/watchdog/check_l3.go index fae7759..0fee453 100644 --- a/internal/watchdog/check_l3.go +++ b/internal/watchdog/check_l3.go @@ -25,7 +25,6 @@ type l3Probe interface { NeighborEstablished(peer net.IP) (bool, error) VNI(vni uint32) (frr.VNIState, error) ExportedRoutes(table uint32, iface string) ([]*net.IPNet, error) - UnreachableDefault(table uint32) (bool, error) LinkProblem(ns, iface string) string } @@ -45,10 +44,6 @@ func (systemProbe) ExportedRoutes(table uint32, iface string) ([]*net.IPNet, err return netif.TableRoutesVia(int(table), iface) } -func (systemProbe) UnreachableDefault(table uint32) (bool, error) { - return netif.HasUnreachableDefault(int(table), l3vni.UnreachableMetric) -} - func (systemProbe) LinkProblem(ns, iface string) string { if ns == "" { return linkProblem(iface) @@ -150,14 +145,6 @@ func checkL3VPC(db *badger.DB, name string, r l3vni.Routing, rmac string, p l3Pr n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d has router mac %q in frr, expected %s", r.VNI, s.RouterMAC, rmac)) } - present, err := p.UnreachableDefault(r.VNI) - switch { - case err != nil: - n.Notify(kindVPC, name, fmt.Sprintf("unreachable default of %s unreadable: %v", r.VRF, err)) - case !present: - n.Notify(kindVPC, name, fmt.Sprintf("no unreachable default in %s: traffic to an unknown destination leaves through the host routing table", r.VRF)) - } - actual, err := p.ExportedRoutes(r.VNI, r.VethHost) if err != nil { n.Notify(kindVPC, name, fmt.Sprintf("routes of %s unreadable: %v", r.VRF, err)) diff --git a/internal/watchdog/check_l3_test.go b/internal/watchdog/check_l3_test.go index f84a6a3..c307b30 100644 --- a/internal/watchdog/check_l3_test.go +++ b/internal/watchdog/check_l3_test.go @@ -19,8 +19,6 @@ type fakeProbe struct { routesErr error links map[string]string vtepErr error - unreachable map[uint32]bool - unreachErr error } func (f *fakeProbe) VTEPAddress(string) (net.IP, error) { @@ -51,13 +49,6 @@ func (f *fakeProbe) ExportedRoutes(table uint32, _ string) ([]*net.IPNet, error) return out, f.routesErr } -func (f *fakeProbe) UnreachableDefault(table uint32) (bool, error) { - if f.unreachable == nil { - return true, f.unreachErr - } - return f.unreachable[table], f.unreachErr -} - func (f *fakeProbe) LinkProblem(ns, iface string) string { return f.links[ns+"/"+iface] } @@ -249,32 +240,3 @@ func TestCheckL3VPCsReportsUnreadableRoutesAndVTEP(t *testing.T) { t.Errorf("RMAC comparée sans VTEP : %q", notified(r)) } } - -func TestCheckL3VPCsReportsAVRFWithoutUnreachableDefault(t *testing.T) { - db := newTestDB(t) - seedResource(t, db, prefixVPC, "vp-s7", state.Running) - seedKV(t, db, "vpc/vp-s7/cidr", "10.241.0.0/16") - seedKV(t, db, "vpc/vp-s7/l3vni", "2700") - seedResource(t, db, prefixVPC, "vp-s8", state.Running) - seedKV(t, db, "vpc/vp-s8/cidr", "10.242.0.0/16") - seedKV(t, db, "vpc/vp-s8/l3vni", "2800") - p := seedRoutedVPC(t) - p.vni[2800] = frr.VNIState{Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:0b"} - p.unreachable = map[uint32]bool{2700: true} - r := &recorder{} - if err := CheckL3VPCs(db, bgpCfg(), p, r); err != nil { - t.Fatal(err) - } - want := []string{"vpc vp-s8: no unreachable default in vrf-s8: traffic to an unknown destination leaves through the host routing table"} - if got := notified(r); !reflect.DeepEqual(got, want) { - t.Errorf("notifications :\n%q\nattendu :\n%q", got, want) - } - - p.unreachable = map[uint32]bool{2700: true, 2800: true} - p.unreachErr = errors.New("netlink refused") - r = &recorder{} - CheckL3VPCs(db, bgpCfg(), p, r) - if !r.hasProblemContaining("unreachable default of vrf-s7 unreadable: netlink refused") || r.hasProblemContaining("no unreachable default") { - t.Errorf("notifications %q", notified(r)) - } -} diff --git a/internal/watchdog/check_public.go b/internal/watchdog/check_public.go deleted file mode 100644 index 8752688..0000000 --- a/internal/watchdog/check_public.go +++ /dev/null @@ -1,39 +0,0 @@ -package watchdog - -import ( - "fmt" - - configuration "git.g3e.fr/syonad/two/internal/config/agent" - "git.g3e.fr/syonad/two/internal/netif" - "git.g3e.fr/syonad/two/internal/watchdog/notify" -) - -const kindPublic = "public" - -type publicProbe interface { - LinkProblem(name string) string - VxlanPorts(bridge string) ([]string, error) -} - -type systemPublicProbe struct{} - -func (systemPublicProbe) LinkProblem(name string) string { return linkProblem(name) } - -func (systemPublicProbe) VxlanPorts(bridge string) ([]string, error) { - return netif.BridgeVxlanPorts(bridge) -} - -func CheckPublicSegment(cfg *configuration.Config, p publicProbe, n notify.Notifier) { - bridge := cfg.PublicBridge() - if problem := p.LinkProblem(bridge); problem != "" { - n.Notify(kindPublic, bridge, problem+" (public bridge, interfaces.internet): the vpcs of this host have no public segment") - return - } - ports, err := p.VxlanPorts(bridge) - switch { - case err != nil: - n.Notify(kindPublic, bridge, fmt.Sprintf("vxlan ports unreadable: %v", err)) - case len(ports) == 0: - n.Notify(kindPublic, bridge, "no vxlan port: the public segment is unreachable from this host") - } -} diff --git a/internal/watchdog/check_public_test.go b/internal/watchdog/check_public_test.go deleted file mode 100644 index f8c0ea8..0000000 --- a/internal/watchdog/check_public_test.go +++ /dev/null @@ -1,77 +0,0 @@ -package watchdog - -import ( - "errors" - "testing" - - configuration "git.g3e.fr/syonad/two/internal/config/agent" -) - -type fakePublicProbe struct { - problems map[string]string - ports []string - err error - asked []string -} - -func (f *fakePublicProbe) LinkProblem(name string) string { - f.asked = append(f.asked, name) - return f.problems[name] -} - -func (f *fakePublicProbe) VxlanPorts(bridge string) ([]string, error) { - f.asked = append(f.asked, "ports:"+bridge) - return f.ports, f.err -} - -func TestCheckPublicSegment_SilentWithAVxlanPort(t *testing.T) { - r := &recorder{} - p := &fakePublicProbe{ports: []string{"vxlan-public"}} - CheckPublicSegment(&configuration.Config{}, p, r) - if len(r.calls) != 0 { - t.Errorf("notifications = %+v, aucune attendue", r.calls) - } - if len(p.asked) != 2 || p.asked[0] != "br-public" || p.asked[1] != "ports:br-public" { - t.Errorf("sondes = %q, br-public attendu par défaut", p.asked) - } -} - -func TestCheckPublicSegment_FollowsInterfacesInternet(t *testing.T) { - r := &recorder{} - p := &fakePublicProbe{ports: []string{"vxlan-public"}} - CheckPublicSegment(&configuration.Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"internet": "br-wan"}}, p, r) - if len(p.asked) != 2 || p.asked[0] != "br-wan" || p.asked[1] != "ports:br-wan" { - t.Errorf("sondes = %q, br-wan attendu", p.asked) - } -} - -func TestCheckPublicSegment_ReportsAMissingBridgeWithoutReadingPorts(t *testing.T) { - r := &recorder{} - p := &fakePublicProbe{problems: map[string]string{"br-public": "interface br-public not found: Link not found"}} - CheckPublicSegment(&configuration.Config{}, p, r) - got := r.forName("br-public") - want := "interface br-public not found: Link not found (public bridge, interfaces.internet): the vpcs of this host have no public segment" - if len(got) != 1 || got[0].kind != "public" || got[0].problem != want { - t.Fatalf("notifications = %+v, une attendue : %q", r.calls, want) - } - if len(p.asked) != 1 { - t.Errorf("ports lus alors que le bridge manque : %q", p.asked) - } -} - -func TestCheckPublicSegment_ReportsABridgeWithoutVxlan(t *testing.T) { - r := &recorder{} - CheckPublicSegment(&configuration.Config{}, &fakePublicProbe{}, r) - got := r.forName("br-public") - if len(got) != 1 || got[0].problem != "no vxlan port: the public segment is unreachable from this host" { - t.Errorf("notifications = %+v", r.calls) - } -} - -func TestCheckPublicSegment_ReportsUnreadablePorts(t *testing.T) { - r := &recorder{} - CheckPublicSegment(&configuration.Config{}, &fakePublicProbe{err: errors.New("netlink: permission denied")}, r) - if !r.hasProblemContaining("vxlan ports unreadable: netlink: permission denied") { - t.Errorf("notifications = %+v", r.calls) - } -} diff --git a/internal/watchdog/watchdog.go b/internal/watchdog/watchdog.go index b49b12c..7a0101f 100644 --- a/internal/watchdog/watchdog.go +++ b/internal/watchdog/watchdog.go @@ -23,7 +23,6 @@ type Watchdog struct { interval time.Duration dbusDown bool l3 l3Probe - public publicProbe } func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *slog.Logger, interval time.Duration) *Watchdog { @@ -42,7 +41,6 @@ func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *sl logger: logger, interval: interval, l3: systemProbe{frr: frr.NewClient()}, - public: systemPublicProbe{}, } } @@ -76,7 +74,6 @@ func (w *Watchdog) tick() { if err := CheckVMs(w.db, w.cfg, u, w.notifier); err != nil { w.logger.Error("watchdog: vm check failed", "err", err) } - CheckPublicSegment(w.cfg, w.public, w.notifier) CheckBGP(w.cfg, w.l3, w.notifier) if err := CheckL3VPCs(w.db, w.cfg, w.l3, w.notifier); err != nil { w.logger.Error("watchdog: l3 vpc check failed", "err", err) diff --git a/internal/watchdog/watchdog_test.go b/internal/watchdog/watchdog_test.go index 87fcfb6..eb43975 100644 --- a/internal/watchdog/watchdog_test.go +++ b/internal/watchdog/watchdog_test.go @@ -74,13 +74,6 @@ func TestNew_IntervalleValideConserve(t *testing.T) { } } -func TestNew_ChecksThePublicSegmentOnTheSystem(t *testing.T) { - w := New(newTestDB(t), testCfg(t), &recorder{}, nil, time.Second) - if _, ok := w.public.(systemPublicProbe); !ok { - t.Errorf("sonde du segment public = %T, systemPublicProbe attendue", w.public) - } -} - func TestNew_LoggerNil(t *testing.T) { w := New(newTestDB(t), testCfg(t), &recorder{}, nil, time.Second) if w.logger == nil { @@ -148,7 +141,6 @@ func TestRun_ErreurDeBaseLogueeEtBoucleContinue(t *testing.T) { n := newChanNotifier() l, buf := testLogger() w := New(db, testCfg(t), n, l, 10*time.Millisecond) - w.public = &fakePublicProbe{ports: []string{"vxlan-public"}} ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond) defer cancel() diff --git a/release_notes/0.3.0.md b/release_notes/0.3.0.md deleted file mode 100644 index 8038a58..0000000 --- a/release_notes/0.3.0.md +++ /dev/null @@ -1,54 +0,0 @@ -# Gabriel - -## Fonctionnalités - -**Délais dédiés : section `times` (#79)** - -- Nouvelle section `times` de la configuration, en secondes : `timeout_vms_stop` (300), - `next_vms_shutdown` (30), `timeout_subnet_stop` (360), `timeout_vpc_stop` (420), - `timeout_subnet_start` (300), `timeout_vms_start` (300), `poll_interval` (2). Elle remplace - `dispatcher.timeout_seconds` et `dispatcher.poll_seconds`, qui servaient à des attentes de - nature différente. Une valeur nulle ou négative, ou `next_vms_shutdown` au moins égal à - `timeout_vms_stop`, fait échouer le démarrage -- **Une VM et son subnet se suppriment d'un coup** : la suppression d'un subnet est acceptée - quand ses VM sont en `deleting`, et attend leur suppression jusqu'à `timeout_subnet_stop`. Le - 409 reste pour une VM ni supprimée ni en `deleting` - -## Correctifs - -- **Chaque VRF de VPC porte une route `unreachable default` (#81).** Une recherche qui échouait - dans la table d'une VRF continuait dans la table `main` de l'hôte : un paquet d'un locataire - vers une adresse inconnue de son VPC sortait par l'underlay, avec `169.254.0.2` pour source - (mesuré en lab). La route est posée juste après la VRF, avec la métrique maximale - `4278198272`, de sorte que toute route réelle reste prioritaire ; elle n'est pas annoncée en - EVPN et elle est retirée au démontage du VPC. Le watchdog signale une VRF qui ne l'a pas. - IPv4 seulement -- **`default_route: true` sans `gateway` est réservé au mode `bridge` (#81)** : refusé (400) en - `vxlan` et en `public_ip`. Hors `bridge`, la gateway lue dans la table de routage de l'hôte - n'est pas sur le subnet des VM : la route par défaut annoncée était inutilisable -- **La suppression d'une VM retire ses sockets QEMU (#84).** Quand QEMU échouait au démarrage - (disque absent par exemple), il pouvait laisser `.sock` dans `serial_dir`, `monitor_dir` ou - `qmp_dir`, que la suppression de la VM ne retirait pas. Les trois sont désormais supprimés une - fois QEMU arrêté ; un fichier absent n'est pas une erreur -- **`system_powerdown` est renvoyé toutes les `next_vms_shutdown` secondes (#79)** pendant - l'arrêt d'une VM, jusqu'à `timeout_vms_stop`. Un seul appui était envoyé : arrivé avant que - l'invité sache le traiter (firmware, chargeur de démarrage), il était perdu, et la suppression - durait les 300 s du délai avant un `quit` brutal (mesuré en lab) -- **La suppression d'un VPC échoue si l'un de ses subnets échoue (#79).** Elle attendait qu'aucun - subnet ne soit plus en `deleting`, puis supprimait le VPC même si un subnet était passé en - `error`. Il en va de même pour un subnet dont une VM attendue passe en `error` - -## Mise à jour depuis la 0.2.0 - -- **`default_route: true` exige une `gateway` hors mode `bridge`** : un appel qui l'omettait en - `vxlan` reçoit désormais un 400. Les subnets existants gardent la route par défaut qu'ils - annonçaient jusqu'à leur recréation -- **Les VPC routés existants n'ont pas la route `unreachable default`** : l'agent ne la pose pas - au démarrage, le watchdog les signale à chaque tick. La recréation du VPC la pose ; d'ici là, - la fuite vers l'underlay décrite plus haut reste possible. Pour la fermer sans recréer le VPC, - la poser à la main sur chaque hyperviseur, la table étant le `l3vni` du VPC : - `ip route replace unreachable default metric 4278198272 table ` -- **La section `dispatcher` n'est plus lue** : restée dans `/etc/two/agent.yml`, elle est ignorée, - et les valeurs par défaut de `times` s'appliquent. Une valeur personnalisée de - `dispatcher.timeout_seconds` est à reporter dans `times.timeout_vms_stop` (et dans les délais - qui en dépendent) diff --git a/scripts/bootstrap_kvm.sh b/scripts/bootstrap_kvm.sh index 341ebba..220a511 100755 --- a/scripts/bootstrap_kvm.sh +++ b/scripts/bootstrap_kvm.sh @@ -77,8 +77,8 @@ kvm_network () { info "réseau" - # Bridge public : sans adresse. Il reçoit le VXLAN du segment public - # (kvm_public_segment) et les veth vp--e des VPC (interfaces.internet). + # Bridge public : créé à vide, réservé pour un usage futur. Aucune adresse, + # aucun esclave, pas référencé dans la config agent. kvm_ensure_bridge "${DRY_RUN}" "${PUBLIC_BRIDGE}" MASTER="" @@ -153,49 +153,6 @@ EOF info " rollback désarmé" } -# VXLAN du segment public, partagé avec les bordures, esclave du bridge public. -# VTEP = IPv4 du bridge principal, comme les VXLAN de l'agent ; sans -# apprentissage, les MAC distantes viennent d'EVPN. Recréé si le VNI ou le VTEP -# a changé. -kvm_public_segment () { - local DRY_RUN="${1}" - local WITH_NETWORK="${2}" - local BRIDGE="${3}" - local PUBLIC_BRIDGE="${4}" - local PUBLIC_VNI="${5}" - local NAME="vxlan-public" - local VTEP CURRENT="" - - [[ ${WITH_NETWORK} -eq ${FLAGS_TRUE} ]] || return 0 - [[ "${PUBLIC_VNI}" =~ ^[0-9]+$ ]] && (( PUBLIC_VNI >= 1 && PUBLIC_VNI <= 16777215 )) \ - || die "VNI du segment public invalide : ${PUBLIC_VNI} (1-16777215)" - - info "segment public : ${NAME}, VNI ${PUBLIC_VNI}, sur ${PUBLIC_BRIDGE}" - - if [[ ${DRY_RUN} -eq ${FLAGS_TRUE} ]] - then - VTEP="" - else - VTEP=$(ip -j addr show dev "${BRIDGE}" | jq -r '[.[0].addr_info[] | select(.family=="inet" and .scope=="global")][0].local // ""') - [[ -n "${VTEP}" ]] || die "aucune adresse IPv4 globale sur ${BRIDGE} pour le VTEP du segment public" - if ip link show dev "${NAME}" >/dev/null 2>&1 - then - CURRENT=$(ip -j -d link show dev "${NAME}" | jq -r '.[0].linkinfo.info_data | "\(.id) \(.local)"') - fi - fi - - if [[ -n "${CURRENT}" && "${CURRENT}" != "${PUBLIC_VNI} ${VTEP}" ]] - then - info " ${NAME} porte ${CURRENT} (VNI VTEP) : recréé" - run "${DRY_RUN}" "ip link del dev '${NAME}'" - CURRENT="" - fi - [[ -n "${CURRENT}" ]] \ - || run "${DRY_RUN}" "ip link add '${NAME}' type vxlan id ${PUBLIC_VNI} local '${VTEP}' dstport 4789 nolearning" - run "${DRY_RUN}" "ip link set dev '${NAME}' mtu 1500 master '${PUBLIC_BRIDGE}'" - run "${DRY_RUN}" "ip link set up dev '${NAME}'" -} - # Point d'entrée appelé par deploy.sh --bootstrap. bootstrap_host () { local DRY_RUN="${1}" @@ -205,10 +162,8 @@ bootstrap_host () { local BRIDGE="${5}" local PUBLIC_BRIDGE="${6}" local ROLLBACK_DELAY="${7}" - local PUBLIC_VNI="${8:-1}" - kvm_packages "${DRY_RUN}" "${WITH_PACKAGES}" - kvm_kernel "${DRY_RUN}" - kvm_network "${DRY_RUN}" "${WITH_NETWORK}" "${UPLINK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${ROLLBACK_DELAY}" - kvm_public_segment "${DRY_RUN}" "${WITH_NETWORK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${PUBLIC_VNI}" + kvm_packages "${DRY_RUN}" "${WITH_PACKAGES}" + kvm_kernel "${DRY_RUN}" + kvm_network "${DRY_RUN}" "${WITH_NETWORK}" "${UPLINK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${ROLLBACK_DELAY}" } diff --git a/scripts/deploy.sh b/scripts/deploy.sh index c431697..b654197 100755 --- a/scripts/deploy.sh +++ b/scripts/deploy.sh @@ -159,7 +159,7 @@ run_bootstrap () { || die "bootstrap_host() introuvable — ni ${SCRIPTS_DIR}/${NAME} ni ${BOOTSTRAP_URL} n'ont pu être chargés" bootstrap_host "${DRY_RUN}" "${FLAGS_packages}" "${FLAGS_network}" \ - "${FLAGS_uplink}" "${FLAGS_bridge}" "${FLAGS_pub_bridge}" "${FLAGS_rollback}" "${FLAGS_public_vni}" + "${FLAGS_uplink}" "${FLAGS_bridge}" "${FLAGS_pub_bridge}" "${FLAGS_rollback}" } resolve_tag () { @@ -335,8 +335,7 @@ main () { DEFINE_boolean 'network' true 'Configure bridges during --bootstrap' 'n' DEFINE_string 'uplink' 'eno1' 'Physical uplink interface' 'u' DEFINE_string 'bridge' 'br-000000' 'Main bridge, uplink is enslaved to it' 'B' - DEFINE_string 'pub_bridge' 'br-public' 'Public bridge, carries vxlan-public' 'P' - DEFINE_integer 'public_vni' 1 'VNI of the public segment (vxlan-public)' 'N' + DEFINE_string 'pub_bridge' 'br-public' 'Reserved empty bridge' 'P' DEFINE_integer 'rollback' 120 'Rollback reboot delay in seconds' 'R' DEFINE_boolean 'verify' true 'Check assets against SHA256SUMS' 'V' diff --git a/test/e2e/build.sh b/test/e2e/build.sh index 992c7ae..786f211 100755 --- a/test/e2e/build.sh +++ b/test/e2e/build.sh @@ -3,42 +3,33 @@ E2E_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" REPO_DIR="$(cd "${E2E_DIR}/../.." && pwd)" BIN_DIR="${BIN_DIR:-${E2E_DIR}/topologies/bin}" -SCRIPTS_DIR="${SCRIPTS_DIR:-${E2E_DIR}/topologies/scripts}" BINARIES="agent dhcp metadata" -SCRIPTS="bootstrap_kvm.sh" usage () { cat >&2 <&2 (cd "${REPO_DIR}" && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o "${BIN_DIR}/${binary}" "./cmd/${binary}") || return 1 done - for script in ${SCRIPTS}; do - echo "== ${script}" >&2 - cp "${REPO_DIR}/scripts/${script}" "${SCRIPTS_DIR}/${script}" || return 1 - done (cd "${BIN_DIR}" && sha256sum ${BINARIES} 2>/dev/null || shasum -a 256 ${BINARIES}) } diff --git a/test/e2e/lib/core.sh b/test/e2e/lib/core.sh index 9002402..fa2a8cf 100644 --- a/test/e2e/lib/core.sh +++ b/test/e2e/lib/core.sh @@ -56,7 +56,7 @@ api_state () { wait_state () { local path="${1}" want="${2}" i s code="" - for i in $(seq 1 240); do + for i in $(seq 1 180); do s=$(api_state "${path}") [ "${s}" = "${want}" ] && return 0 if [ "${want}" = deleted ] && [ -z "${s}" ]; then diff --git a/test/e2e/suite/11-validation.sh b/test/e2e/suite/11-validation.sh index 04df20d..c9684a2 100644 --- a/test/e2e/suite/11-validation.sh +++ b/test/e2e/suite/11-validation.sh @@ -1,6 +1,6 @@ # 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, #62, #74, #81 +# tickets: #41, #57, #33, #62, #74 on hv1 <<'NODE' check "VPC vp-t11a, l3vni 1100 (témoin)" vpc_create vp-t11a 10.11.0.0/16 1100 @@ -19,8 +19,6 @@ check "sn-t11a : adresse d'émission calculée .253" test "$(api_field subnets/s 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 : default_route sans gateway 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","default_route":true}' -check "subnet : default_route sans gateway, mode omis, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","vxlan_id":1109,"cidr":"10.11.9.0/24","default_route":true}' 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"}' diff --git a/test/e2e/suite/12-etats.sh b/test/e2e/suite/12-etats.sh index acd71a4..aab8d3e 100644 --- a/test/e2e/suite/12-etats.sh +++ b/test/e2e/suite/12-etats.sh @@ -1,6 +1,6 @@ -# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom +# 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, #84, #79 +# tickets: #41 on hv1 <<'NODE' check "VPC vp-t12a" vpc_create vp-t12a 10.12.0.0/16 @@ -23,11 +23,8 @@ check "suppression d'un VPC inconnu, 404" expect_code 404 api_code DELETE vpcs/v 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 -info "t12-err : sockets laissés par QEMU : $(ls /run/two/vms/serial/t12-err.sock /run/two/vms/monitor/t12-err.sock /run/two/vms/qmp/t12-err.sock 2>&1 | tr '\n' ' ')" -check "t12-err : les trois sockets QEMU posés à la main s'ils manquent" sh -c 'for d in serial monitor qmp; do [ -e "/run/two/vms/${d}/t12-err.sock" ] || : > "/run/two/vms/${d}/t12-err.sock" || exit 1; done' 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 : aucun socket QEMU laissé dans /run/two/vms" sh -c 'for d in serial monitor qmp; do [ ! -e "/run/two/vms/${d}/t12-err.sock" ] || { echo "/run/two/vms/${d}/t12-err.sock laissé"; exit 1; }; done' 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 @@ -41,16 +38,4 @@ 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é" wait_state vpcs/vp-t12a deleted check "vp-t12a recréé sous le même nom" vpc_create vp-t12a 10.12.0.0/16 - -check "subnet sn-t12q (VNI 1202)" subnet_create sn-t12q vp-t12a 1202 10.12.2.0/24 -check "VM t12-q" vm_create t12-q sn-t12q 10.12.2.10 -sleep 3 -T12Q=$(date +%s) -check "t12-q : suppression 3 s après running, 202" expect_code 202 api_code DELETE vms/t12-q -check "sn-t12q : suppression envoyée aussitôt, acceptée malgré t12-q en deleting, 202" expect_code 202 api_code DELETE subnets/sn-t12q -info "sn-t12q juste après sa suppression : $(api_state subnets/sn-t12q), t12-q : $(api_state vms/t12-q)" -check "t12-q supprimée" wait_state vms/t12-q deleted -check "sn-t12q supprimé après t12-q" wait_state subnets/sn-t12q deleted -info "t12-q puis sn-t12q supprimés en $(( $(date +%s) - T12Q )) s" -check "t12-q : arrêtée bien avant times.timeout_vms_stop (300 s), par un system_powerdown renvoyé si le premier est perdu" test "$(( $(date +%s) - T12Q ))" -lt 200 NODE diff --git a/test/e2e/suite/51-l3vni.sh b/test/e2e/suite/51-l3vni.sh index 4e562f0..879e2cb 100644 --- a/test/e2e/suite/51-l3vni.sh +++ b/test/e2e/suite/51-l3vni.sh @@ -1,6 +1,6 @@ -# 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, unreachable default dans la VRF, démontage d'un VPC routé +# 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'un VPC routé # hôtes: hv1 hv2 -# tickets: #41, #81 +# tickets: #41 on hv1 <<'NODE' KEY=$(vm_key) @@ -23,9 +23,6 @@ check "hv1 : vrf-t51 contient exactement brl3-t51 et l3-t51-o" sh -c "[ \"\$1\" 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 : table 5100 de vrf-t51 : unreachable default de métrique 4278198272" sh -c "ip -4 route show table 5100 | grep -q '^unreachable default metric 4278198272'" -check "hv1 : adresse du VPC inconnue (10.51.5.5) injoignable dans vrf-t51, pas de repli sur la table main" sh -c "ip -4 route get 10.51.5.5 vrf vrf-t51 2>&1 | grep -q 'No route to host'" -check "hv1 : adresse externe (8.8.8.8) injoignable dans vrf-t51" sh -c "ip -4 route get 8.8.8.8 vrf vrf-t51 2>&1 | grep -q 'No route to host'" 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)" @@ -44,7 +41,6 @@ check "hv2 : RMAC de hv1 dans la FDB de vxl3-t51" sh -c "bridge fdb show dev vxl 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 : aucune RT-5 0.0.0.0/0 de hv1 (RD 192.168.14.11:5100) : l'unreachable default n'est pas annoncée" sh -c "! vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.11:5100 type prefix' | grep -q '\[0.0.0.0\]'" 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' @@ -60,7 +56,6 @@ check "TTL 2 : expire dans la VRF de hv1 (169.254.0.1)" vm_grep vp-t51 10.51.1.1 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' -check "t51-a vers une adresse inconnue du VPC (10.51.5.5) : refusé par vrf-t51 (169.254.0.1), rien vers l'underlay" vm_grep vp-t51 10.51.1.10 'ping -n -c 2 -W 2 10.51.5.5' 'From 169.254.0.1 .*Unreachable' NODE on hv2 <<'NODE' BGPD=$(pidof bgpd) @@ -69,11 +64,9 @@ 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 : table 5101 de vrf-t51b : unreachable default avant le démontage (témoin)" sh -c "ip -4 route show table 5101 | grep -q '^unreachable default metric 4278198272'" 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 : table 5101 vide après le démontage, unreachable default comprise" sh -c "! ip -4 route show table 5101 2>&1 | grep -qE '^(unreachable|default|[0-9])'" 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 diff --git a/test/e2e/suite/53-watchdog-l3.sh b/test/e2e/suite/53-watchdog-l3.sh index 7d88c7e..f0a6def 100644 --- a/test/e2e/suite/53-watchdog-l3.sh +++ b/test/e2e/suite/53-watchdog-l3.sh @@ -1,6 +1,6 @@ -# fonctionnalité: watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, unreachable default absente signalée, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais +# fonctionnalité: watchdog d'un VPC routé — /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, #81 +# tickets: #41 on hv1 <<'NODE' check "hv1 : VPC vp-t53, l3vni 5300" vpc_create vp-t53 10.53.0.0/16 5300 @@ -28,10 +28,6 @@ check "watchdog : /32 de t53-m retiré à la main" ip route del 10.53.1.50/32 vr 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 sur l'unreachable default avant son retrait (témoin)" watchdog_quiet_about 60 "no unreachable default" -check "watchdog : unreachable default retirée à la main de la table 5300" ip route del unreachable default metric 4278198272 table 5300 -check "watchdog : unreachable default absente signalée" wait_watchdog "no unreachable default in vrf-t53" -check "watchdog : unreachable default rétablie" ip route replace unreachable default metric 4278198272 table 5300 check "watchdog : aucune alerte BGP ni L3VNI sur hv1" watchdog_l3_quiet 60 NODE on hv3 <<'NODE' diff --git a/test/e2e/topologies/evpn-2hv.yml b/test/e2e/topologies/evpn-2hv.yml index c89f668..8041ab3 100644 --- a/test/e2e/topologies/evpn-2hv.yml +++ b/test/e2e/topologies/evpn-2hv.yml @@ -35,11 +35,11 @@ nodes: { 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, - post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin, scripts: scripts }, + 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, scripts: scripts }, + post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin }, services: [agent.service] } diff --git a/test/e2e/topologies/evpn-3hv.yml b/test/e2e/topologies/evpn-3hv.yml index d3b5d2c..a32ac1c 100644 --- a/test/e2e/topologies/evpn-3hv.yml +++ b/test/e2e/topologies/evpn-3hv.yml @@ -35,18 +35,18 @@ nodes: { 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, - post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin, scripts: scripts }, + 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, scripts: scripts }, + post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.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, scripts: scripts }, + post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin }, services: [agent.service] } bd1: { role: host, image: debian12, cpus: 1, memory: 1024, segments: [underlay], diff --git a/test/e2e/topologies/provision/border.sh b/test/e2e/topologies/provision/border.sh index c72c9b0..524bca2 100755 --- a/test/e2e/topologies/provision/border.sh +++ b/test/e2e/topologies/provision/border.sh @@ -1,16 +1,16 @@ #!/bin/sh set -eu -VNI=1 +VNI=66001 GATEWAY=240.0.0.1/24 -GATEWAY_MAC=02:01:00:00:00:01 +GATEWAY_MAC=02:01:00:01:01:d1 DESTINATION=240.255.0.1/32 VTEP=$(ip -4 -o addr show dev "${LAB_UPLINK}" scope global | awk 'NR == 1 {sub("/.*", "", $4); print $4}') [ -n "${VTEP}" ] || { echo "border: no IPv4 on ${LAB_UPLINK}" >&2; exit 1; } ip link add br-public type bridge ip link set br-public address "${GATEWAY_MAC}" -ip link add vxlan-public type vxlan id "${VNI}" local "${VTEP}" dstport 4789 nolearning -ip link set vxlan-public mtu 1500 master br-public -ip link set vxlan-public up +ip link add "vxlan-${VNI}" type vxlan id "${VNI}" local "${VTEP}" dstport 4789 nolearning +ip link set "vxlan-${VNI}" mtu 1500 master br-public +ip link set "vxlan-${VNI}" up ip link set br-public up ip addr add "${GATEWAY}" dev br-public ip link add internet type dummy diff --git a/test/e2e/topologies/provision/hypervisor.sh b/test/e2e/topologies/provision/hypervisor.sh index 4d4b52d..3257dc1 100755 --- a/test/e2e/topologies/provision/hypervisor.sh +++ b/test/e2e/topologies/provision/hypervisor.sh @@ -1,7 +1,6 @@ #!/bin/sh set -eu RELEASE=0.2.0 -PUBLIC_VNI=1 GIT_SERVER=https://git.g3e.fr/ REPO=syonad/two n=0 @@ -29,11 +28,6 @@ for script in deploy.sh bootstrap_kvm.sh; do done chmod 0755 deploy.sh bootstrap_kvm.sh bash ./deploy.sh --noup_script -i -u "${LAB_UPLINK}" -t "${RELEASE}" -if [ -f "${LAB_FILES}/scripts/bootstrap_kvm.sh" ]; then - bash -c 'FLAGS_TRUE=0; FLAGS_FALSE=1; . ./deploy.sh && . "$1" && kvm_public_segment "${FLAGS_FALSE}" "${FLAGS_TRUE}" br-000000 br-public "$2"' \ - lab "${LAB_FILES}/scripts/bootstrap_kvm.sh" "${PUBLIC_VNI}" - echo "lab: segment public posé par le bootstrap_kvm.sh de l'arbre courant (VNI ${PUBLIC_VNI})" -fi for binary in "${LAB_FILES}"/bin/*; do [ -f "${binary}" ] || continue name=$(basename "${binary}") diff --git a/test/e2e/topologies/scripts/.gitkeep b/test/e2e/topologies/scripts/.gitkeep deleted file mode 100644 index e69de29..0000000