Compare commits
13 commits
edfd24f92b
...
630cb99048
| Author | SHA1 | Date | |
|---|---|---|---|
|
630cb99048 |
|||
|
f799f8d83e |
|||
|
e6c758af78 |
|||
|
aeb5ddc1bc |
|||
|
62edefee5a |
|||
|
de639667ed |
|||
|
0d4dc9fd91 |
|||
|
7672445fe7 |
|||
|
6d3d6314e2 |
|||
|
583fd89adb |
|||
|
45b226f0bc |
|||
|
cc8ddfe882 |
|||
|
dd9844284d |
39 changed files with 1101 additions and 122 deletions
|
|
@ -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 first
|
||||
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
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
|
|
@ -234,7 +234,8 @@ 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)
|
||||
supplied on a vxlan subnet (it is computed); default_route true without gateway on a
|
||||
vxlan or public_ip subnet
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
|
|
@ -288,7 +289,7 @@ paths:
|
|||
"404":
|
||||
$ref: "#/components/responses/NotFound"
|
||||
"409":
|
||||
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
|
||||
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
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
|
|
@ -408,8 +409,9 @@ 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.
|
||||
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 — 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
|
||||
mode, which has no VPC route), so VPC traffic never leaves through a public gateway.
|
||||
default: false
|
||||
gateway:
|
||||
|
|
|
|||
|
|
@ -19,12 +19,22 @@ worker:
|
|||
# Maximum number of commands queued before Dispatch blocks
|
||||
buffer_size: 100
|
||||
|
||||
# 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
|
||||
# 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
|
||||
|
||||
# Bridge interface used when the requested iface_type is not found in interfaces
|
||||
default_interface: br-000000
|
||||
|
|
|
|||
|
|
@ -29,6 +29,13 @@ 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
|
||||
|
|
@ -43,7 +50,8 @@ 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 ``dispatcher.timeout_seconds``.
|
||||
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.
|
||||
|
||||
Arrêt de l'agent
|
||||
----------------
|
||||
|
|
|
|||
|
|
@ -40,7 +40,10 @@ 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.
|
||||
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.
|
||||
|
||||
Pas de rollback
|
||||
---------------
|
||||
|
|
|
|||
|
|
@ -172,7 +172,9 @@ 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.
|
||||
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``.
|
||||
|
||||
``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é.
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ subnets. L'agent n'impose que la première borne (le RD ``<VTEP>:<l3vni>`` porte
|
|||
|
||||
.. code-block:: text
|
||||
|
||||
vrf-<id> VRF, table de routage = l3vni
|
||||
vrf-<id> VRF, table de routage = l3vni, unreachable default metric 4278198272
|
||||
├── brl3-<id> bridge sans adresse, MAC de routeur 02:02:<IPv4 du VTEP>
|
||||
│ └── vxl3-<id> VXLAN du l3vni, VTEP = IPv4 primaire de default_interface
|
||||
└── l3-<id>-o 169.254.0.1/30 ── l3-<id>-i 169.254.0.2/30, dans le netns du VPC
|
||||
|
|
@ -56,8 +56,18 @@ touche pas au réglage global, que ``bootstrap_kvm.sh`` met déjà à 1. FRR re
|
|||
``router bgp <asn> vrf vrf-<id>`` avec RD ``<VTEP>:<l3vni>`` et RT ``<asn>:<l3vni>``, et
|
||||
l'export des routes du ``cidr`` présentes dans la VRF.
|
||||
|
||||
La suppression retire d'abord la configuration de routage de FRR, puis les interfaces, puis la
|
||||
VRF de FRR. Cet ordre est imposé : supprimer la VRF du noyau sous une instance BGP encore
|
||||
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 <https://git.g3e.fr/syonad/two/issues/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
|
||||
configurée fait planter ``bgpd`` (FRR 10.7.1).
|
||||
|
||||
Subnet
|
||||
|
|
|
|||
|
|
@ -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
|
||||
``dispatcher.timeout_seconds``. Il n'est refusé en **422** que si le VPC est absent, en ``error``
|
||||
``times.timeout_subnet_start``. 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
|
||||
|
|
|
|||
|
|
@ -296,11 +296,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
|
||||
- #41, #57, #33, #62, #74, #81
|
||||
* - ``12-etats``
|
||||
- machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom
|
||||
- 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
|
||||
- hv1
|
||||
- #41
|
||||
- #41, #84, #79
|
||||
* - ``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
|
||||
|
|
@ -370,17 +370,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, 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, unreachable default dans la VRF, démontage d'un VPC routé
|
||||
- hv1 hv2
|
||||
- #41
|
||||
- #41, #81
|
||||
* - ``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é, 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é, unreachable default absente signalée, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais
|
||||
- hv1 hv3
|
||||
- #41
|
||||
- #41, #81
|
||||
* - ``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
|
||||
|
|
@ -416,7 +416,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'à 360 s.
|
||||
attend jusqu'à 480 s, au-delà du ``times.timeout_vpc_stop`` par défaut (420 s).
|
||||
|
||||
Hypothèses vérifiées en lab, à garder en tête en écrivant un test :
|
||||
|
||||
|
|
|
|||
|
|
@ -44,14 +44,18 @@ un état stable.
|
|||
|
||||
Trois règles pour un appelant robuste :
|
||||
|
||||
* **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.
|
||||
* **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.
|
||||
* **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 ``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``.
|
||||
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.
|
||||
|
||||
Codes de retour
|
||||
---------------
|
||||
|
|
@ -78,8 +82,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 non supprimées
|
||||
qui l'utilisent encore
|
||||
autre VPC, ou ``l3vni`` demandée sans section ``bgp`` ; pour un subnet, VM qui l'utilisent
|
||||
encore, ni supprimées ni en ``deleting``
|
||||
* - ``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
|
||||
|
|
|
|||
|
|
@ -72,21 +72,49 @@ Exécution des commandes
|
|||
count: 4
|
||||
buffer_size: 100
|
||||
|
||||
dispatcher:
|
||||
timeout_seconds: 300
|
||||
poll_seconds: 2
|
||||
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
|
||||
|
||||
``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.
|
||||
|
||||
``dispatcher.timeout_seconds`` borne les opérations qui attendent une transition d'état, dont
|
||||
l'extinction d'une VM.
|
||||
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.
|
||||
|
||||
.. warning::
|
||||
|
||||
À 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.
|
||||
À 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.
|
||||
|
||||
Correspondance des interfaces
|
||||
-----------------------------
|
||||
|
|
|
|||
|
|
@ -45,7 +45,10 @@ Avec une section ``bgp`` dans la configuration, il contrôle aussi le plan de co
|
|||
``Established`` (``show bgp neighbors <ip>``).
|
||||
* **VPC routés** (``l3vni``, état ``running``) : présence et état des interfaces ``vrf-<id>``,
|
||||
``brl3-<id>``, ``vxl3-<id>``, ``l3-<id>-o`` et, dans le netns, ``l3-<id>-i`` ; L3VNI de type
|
||||
``L3``, ``Up``, avec la MAC de routeur attendue (``show evpn vni <l3vni>``).
|
||||
``L3``, ``Up``, avec la MAC de routeur attendue (``show evpn vni <l3vni>``) ; 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.
|
||||
* **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`` —
|
||||
|
|
|
|||
|
|
@ -117,6 +117,10 @@ Sockets par VM
|
|||
/run/two/vms/monitor/<vm>.sock monitor QEMU
|
||||
/run/two/vms/qmp/<vm>.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
|
||||
|
|
|
|||
|
|
@ -499,3 +499,42 @@ 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())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -78,6 +78,11 @@ 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,
|
||||
|
|
|
|||
|
|
@ -24,10 +24,7 @@ type Config struct {
|
|||
Count int `mapstructure:"count"`
|
||||
BufferSize int `mapstructure:"buffer_size"`
|
||||
} `mapstructure:"worker"`
|
||||
Dispatcher struct {
|
||||
TimeoutSeconds int `mapstructure:"timeout_seconds"`
|
||||
PollSeconds int `mapstructure:"poll_seconds"`
|
||||
} `mapstructure:"dispatcher"`
|
||||
Times Times `mapstructure:"times"`
|
||||
Logger struct {
|
||||
Level string `mapstructure:"level"`
|
||||
Debug bool `mapstructure:"debug"`
|
||||
|
|
@ -73,8 +70,13 @@ func LoadConfig(path string) (*Config, error) {
|
|||
v.SetDefault("prometheus.port", 9090)
|
||||
v.SetDefault("worker.count", 4)
|
||||
v.SetDefault("worker.buffer_size", 100)
|
||||
v.SetDefault("dispatcher.timeout_seconds", 300)
|
||||
v.SetDefault("dispatcher.poll_seconds", 2)
|
||||
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("metadata.run_dir", "/run/two/metadata")
|
||||
v.SetDefault("dhcp.backend", BackendTwo)
|
||||
v.SetDefault("qemu.ovmf_code_path", "/usr/share/OVMF/OVMF_CODE.fd")
|
||||
|
|
@ -106,6 +108,9 @@ 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
|
||||
}
|
||||
|
|
|
|||
64
internal/config/agent/times.go
Normal file
64
internal/config/agent/times.go
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
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
|
||||
}
|
||||
95
internal/config/agent/times_test.go
Normal file
95
internal/config/agent/times_test.go
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,6 +1,7 @@
|
|||
package dispatcher
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strconv"
|
||||
|
|
@ -93,23 +94,21 @@ func (c CreateSubnetCommand) Prepare(db *badger.DB, cfg *configuration.Config) e
|
|||
}
|
||||
|
||||
func (c CreateSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
|
||||
timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second)
|
||||
for {
|
||||
err := waitUntil(cfg.Times.SubnetStart(), cfg.Times.Poll(), func() (bool, error) {
|
||||
vpcState, err := state.Get(db, "vpc/"+c.VPC)
|
||||
if err != nil {
|
||||
return fmt.Errorf("vpc %q not found while waiting", c.VPC)
|
||||
return false, fmt.Errorf("vpc %q not found while waiting", c.VPC)
|
||||
}
|
||||
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):
|
||||
if vpcState != state.Running && vpcState != state.Creating {
|
||||
return false, fmt.Errorf("vpc %q is %s, cannot create subnet %q", c.VPC, vpcState, c.Name)
|
||||
}
|
||||
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)
|
||||
}
|
||||
|
|
@ -132,12 +131,41 @@ func (c DeleteSubnetCommand) Prepare(db *badger.DB, _ *configuration.Config) err
|
|||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(vms) > 0 {
|
||||
return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(vms, ", "))
|
||||
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, ", "))
|
||||
}
|
||||
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 {
|
||||
|
|
@ -159,6 +187,9 @@ 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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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-b, i-c`) {
|
||||
if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-c`) {
|
||||
t.Fatalf("erreur %v", err)
|
||||
}
|
||||
if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "running" {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
package dispatcher
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"strconv"
|
||||
|
|
@ -151,24 +152,23 @@ func allocateMetadataPort(db *badger.DB) (int, error) {
|
|||
}
|
||||
|
||||
func (c StartVMCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
|
||||
timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second)
|
||||
timeout := time.Now().Add(cfg.Times.VMsStart())
|
||||
for _, n := range c.NICs {
|
||||
for {
|
||||
err := waitUntil(time.Until(timeout), cfg.Times.Poll(), func() (bool, error) {
|
||||
subnetState, err := state.Get(db, "subnet/"+n.Subnet)
|
||||
if err != nil {
|
||||
return fmt.Errorf("subnet %q not found while waiting", n.Subnet)
|
||||
return false, fmt.Errorf("subnet %q not found while waiting", n.Subnet)
|
||||
}
|
||||
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):
|
||||
if subnetState != state.Running && subnetState != state.Creating {
|
||||
return false, fmt.Errorf("subnet %q is %s, cannot start vm %q", n.Subnet, subnetState, c.Name)
|
||||
}
|
||||
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)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
package dispatcher
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"strconv"
|
||||
|
|
@ -129,31 +130,8 @@ func (c DeleteVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error
|
|||
}
|
||||
|
||||
func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
|
||||
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 := waitSubnetsDeleted(db, c.Name, cfg.Times.VPCStop(), cfg.Times.Poll()); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := vpc.DeleteVPC(db, c.Name); err != nil {
|
||||
return err
|
||||
|
|
@ -167,3 +145,35 @@ 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
|
||||
}
|
||||
|
|
|
|||
26
internal/dispatcher/agent/wait.go
Normal file
26
internal/dispatcher/agent/wait.go
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
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):
|
||||
}
|
||||
}
|
||||
}
|
||||
168
internal/dispatcher/agent/wait_test.go
Normal file
168
internal/dispatcher/agent/wait_test.go
Normal file
|
|
@ -0,0 +1,168 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
|
|
@ -23,6 +23,8 @@ 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
|
||||
|
|
@ -87,6 +89,14 @@ 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) }
|
||||
|
|
|
|||
|
|
@ -14,6 +14,8 @@ 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)}
|
||||
|
|
@ -84,6 +86,7 @@ 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) }},
|
||||
|
|
@ -123,6 +126,9 @@ 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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -83,6 +83,14 @@ 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))
|
||||
}
|
||||
|
|
@ -121,6 +129,7 @@ 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",
|
||||
|
|
@ -179,6 +188,7 @@ 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) {
|
||||
|
|
@ -209,9 +219,39 @@ 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) != 6 {
|
||||
if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 7 {
|
||||
t.Errorf("erreur %v, appels %q", err, f.calls)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,11 +3,16 @@
|
|||
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)
|
||||
}
|
||||
|
|
@ -45,3 +50,44 @@ 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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,3 +18,15 @@ 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")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,10 @@
|
|||
package vm
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"time"
|
||||
|
|
@ -47,16 +50,14 @@ 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
|
||||
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
|
||||
shutdownQEMU(qmp.Send, socketPath, cfg.Times.VMsStop(), cfg.Times.VMsShutdown(), cfg.Times.Poll())
|
||||
}
|
||||
// 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 {
|
||||
|
|
@ -90,6 +91,16 @@ 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 {
|
||||
|
|
@ -99,15 +110,31 @@ func removeDHCPFiles(d vmData, name string, backend dhcpbackend.Backend) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func waitQMPDead(socketPath string, timeout, poll time.Duration) {
|
||||
timer := time.After(timeout)
|
||||
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()
|
||||
for {
|
||||
select {
|
||||
case <-timer:
|
||||
qmp.Send(socketPath, []string{`{"execute":"quit"}`})
|
||||
case <-deadline:
|
||||
send(socketPath, []string{qmpQuit})
|
||||
return
|
||||
case <-again.C:
|
||||
if _, err := send(socketPath, []string{qmpPowerdown}); err != nil {
|
||||
return
|
||||
}
|
||||
case <-time.After(poll):
|
||||
if _, err := qmp.Send(socketPath, nil); err != nil {
|
||||
if _, err := send(socketPath, nil); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
|
|
|||
86
internal/vm/delete_test.go
Normal file
86
internal/vm/delete_test.go
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
102
internal/vm/shutdown_test.go
Normal file
102
internal/vm/shutdown_test.go
Normal file
|
|
@ -0,0 +1,102 @@
|
|||
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)
|
||||
}
|
||||
}
|
||||
|
|
@ -25,6 +25,7 @@ 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
|
||||
}
|
||||
|
||||
|
|
@ -44,6 +45,10 @@ 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)
|
||||
|
|
@ -145,6 +150,14 @@ 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))
|
||||
|
|
|
|||
|
|
@ -19,6 +19,8 @@ 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) {
|
||||
|
|
@ -49,6 +51,13 @@ 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]
|
||||
}
|
||||
|
|
@ -240,3 +249,32 @@ 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))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
54
release_notes/0.3.0.md
Normal file
54
release_notes/0.3.0.md
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
# 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 `<vm>.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 <l3vni>`
|
||||
- **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)
|
||||
|
|
@ -56,7 +56,7 @@ api_state () {
|
|||
|
||||
wait_state () {
|
||||
local path="${1}" want="${2}" i s code=""
|
||||
for i in $(seq 1 180); do
|
||||
for i in $(seq 1 240); do
|
||||
s=$(api_state "${path}")
|
||||
[ "${s}" = "${want}" ] && return 0
|
||||
if [ "${want}" = deleted ] && [ -z "${s}" ]; then
|
||||
|
|
|
|||
|
|
@ -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
|
||||
# tickets: #41, #57, #33, #62, #74, #81
|
||||
|
||||
on hv1 <<'NODE'
|
||||
check "VPC vp-t11a, l3vni 1100 (témoin)" vpc_create vp-t11a 10.11.0.0/16 1100
|
||||
|
|
@ -19,6 +19,8 @@ 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"}'
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom
|
||||
# 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
|
||||
# hôtes: hv1
|
||||
# tickets: #41
|
||||
# tickets: #41, #84, #79
|
||||
|
||||
on hv1 <<'NODE'
|
||||
check "VPC vp-t12a" vpc_create vp-t12a 10.12.0.0/16
|
||||
|
|
@ -23,8 +23,11 @@ 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
|
||||
|
|
@ -38,4 +41,16 @@ 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
|
||||
|
|
|
|||
|
|
@ -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, 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, unreachable default dans la VRF, démontage d'un VPC routé
|
||||
# hôtes: hv1 hv2
|
||||
# tickets: #41
|
||||
# tickets: #41, #81
|
||||
|
||||
on hv1 <<'NODE'
|
||||
KEY=$(vm_key)
|
||||
|
|
@ -23,6 +23,9 @@ 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)"
|
||||
|
|
@ -41,6 +44,7 @@ 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'
|
||||
|
|
@ -56,6 +60,7 @@ 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)
|
||||
|
|
@ -64,9 +69,11 @@ 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
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
# 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
|
||||
# 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
|
||||
# hôtes: hv1 hv3
|
||||
# tickets: #41
|
||||
# tickets: #41, #81
|
||||
|
||||
on hv1 <<'NODE'
|
||||
check "hv1 : VPC vp-t53, l3vni 5300" vpc_create vp-t53 10.53.0.0/16 5300
|
||||
|
|
@ -28,6 +28,10 @@ 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'
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue