Compare commits

...

13 commits

Author SHA1 Message Date
630cb99048
f-79: doc: section times, suppressions en cascade, notes 0.3.0 #79
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 19:28:28 +01:00
f799f8d83e
f-79: e2e: VM et subnet supprimés d'un coup, wait_state à 480 s #79
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 19:27:38 +01:00
e6c758af78
f-79: agent: section times, renvoi de system_powerdown, attentes #79
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 19:27:28 +01:00
aeb5ddc1bc
Merge branch 'feature-84'
All checks were successful
Documentation / publish (push) Successful in 1m40s
2026-10-25 19:25:54 +01:00
62edefee5a
f-84: doc: sockets QEMU retirés à la suppression, notes 0.3.0 #84
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 19:25:25 +01:00
de639667ed
f-84: e2e: 12-etats, aucun socket QEMU laissé par t12-err #84
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 19:24:19 +01:00
0d4dc9fd91
f-84: vm: sockets QEMU retirés à la suppression d'une VM #84
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 19:24:18 +01:00
7672445fe7
Merge branch 'feature-81'
All checks were successful
Documentation / publish (push) Successful in 1m45s
2026-10-25 19:23:04 +01:00
6d3d6314e2
f-81: doc: unreachable default, default_route, notes 0.3.0 #81
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 15:16:50 +01:00
583fd89adb
f-81: e2e: refus du cas 2, unreachable default dans la VRF #81
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 15:16:50 +01:00
45b226f0bc
f-81: watchdog: VRF sans route unreachable default signalée #81
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 11:53:45 +01:00
cc8ddfe882
f-81: l3vni: route unreachable default dans chaque VRF de VPC #81
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 11:53:39 +01:00
dd9844284d
f-81: api: default_route sans gateway réservé au mode bridge #81
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 11:53:33 +01:00
39 changed files with 1101 additions and 122 deletions

View file

@ -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:

View file

@ -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

View file

@ -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
----------------

View file

@ -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
---------------

View file

@ -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é.

View file

@ -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

View file

@ -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

View file

@ -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 :

View file

@ -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

View file

@ -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
-----------------------------

View file

@ -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`` —

View file

@ -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

View file

@ -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())
}
}
}

View file

@ -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,

View file

@ -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
}

View 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
}

View 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)
}
}
}

View file

@ -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
}

View file

@ -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" {

View file

@ -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)

View file

@ -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
}

View 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):
}
}
}

View 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)
}
}

View file

@ -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) }

View file

@ -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)
}

View file

@ -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)
}
}

View file

@ -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
}

View file

@ -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")
}

View file

@ -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
}
}

View 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)
}
}

View 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)
}
}

View file

@ -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))

View file

@ -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
View 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)

View file

@ -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

View file

@ -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"}'

View file

@ -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

View file

@ -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

View file

@ -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'