Compare commits

..

2 commits

Author SHA1 Message Date
91c0cc03d5
f-87: e2e: advertise-default-gw sur les bordures, gateway en type 2 #87
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 19:19:45 +01:00
811e69dac2
f-87: e2e: bordures bd1 et bd2 dans evpn-3hv, VNI 66001, gateway anycast #87
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-25 13:18:24 +01:00
57 changed files with 152 additions and 1391 deletions

2
.gitignore vendored
View file

@ -37,5 +37,3 @@ docs/_build/
# Binaires compilés en local pour le lab (test/e2e/build.sh)
test/e2e/topologies/bin/*
!test/e2e/topologies/bin/.gitkeep
test/e2e/topologies/scripts/*
!test/e2e/topologies/scripts/.gitkeep

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 or deleting; subnets still deleting are awaited by the asynchronous deletion
description: VPC not deletable — only running or error states can be deleted, and all its subnets must be deleted first
content:
application/json:
schema:
@ -234,8 +234,7 @@ paths:
"400":
description: >
Missing required field; interface_ip missing on a bridge or public_ip subnet, or
supplied on a vxlan subnet (it is computed); default_route true without gateway on a
vxlan or public_ip subnet
supplied on a vxlan subnet (it is computed)
content:
application/json:
schema:
@ -289,7 +288,7 @@ paths:
"404":
$ref: "#/components/responses/NotFound"
"409":
description: Subnet not deletable — only running or error states can be deleted, and every VM with an interface on it must be deleted or deleting; VMs still deleting are awaited by the asynchronous deletion
description: Subnet not deletable — only running or error states can be deleted, and no VM that is not deleted may still have an interface on it
content:
application/json:
schema:
@ -409,9 +408,8 @@ components:
description: >
A default route is always advertised via DHCP; this flag only chooses its next-hop.
When false, the next-hop is the subnet interface_ip. When true, it is the `gateway`
field if supplied, otherwise the gateway read from the host routing table — this last
case is bridge mode only (400 in vxlan and public_ip modes, whose guests do not share
the L2 segment of the host gateway). The route to the VPC CIDR always keeps interface_ip as its next-hop (except in bridge
field if supplied, otherwise the gateway read from the host routing table.
The route to the VPC CIDR always keeps interface_ip as its next-hop (except in bridge
mode, which has no VPC route), so VPC traffic never leaves through a public gateway.
default: false
gateway:

View file

@ -19,32 +19,20 @@ worker:
# Maximum number of commands queued before Dispatch blocks
buffer_size: 100
# Timing (in seconds) for commands that wait on resource state transitions
times:
# Graceful VM shutdown before QMP quit
timeout_vms_stop: 300
# Interval between two system_powerdown during the shutdown
next_vms_shutdown: 30
# Subnet deletion: wait for its VMs still deleting
timeout_subnet_stop: 360
# VPC deletion: wait for its subnets still deleting
timeout_vpc_stop: 420
# Subnet creation: wait for its VPC to be running
timeout_subnet_start: 300
# VM creation: wait for the subnets of its interfaces to be running
timeout_vms_start: 300
# Interval between each state check
poll_interval: 2
# Timing for commands that wait on resource state transitions
dispatcher:
# How long (in seconds) to wait before giving up
timeout_seconds: 300
# Interval (in seconds) between each state check
poll_seconds: 2
# Bridge interface used when the requested iface_type is not found in interfaces
default_interface: br-000000
# Map of logical interface types to physical bridge names on this host.
# internet: public bridge, carrying vxlan-public (deploy.sh --public_vni); every VPC
# plugs its vp-<id>-e veth into it. br-public when absent, never default_interface.
# Map of logical interface types to physical bridge names on this host
interfaces:
vms: br-000000
internet: br-public
internet: br-000000
admin: br-000000
# MTU, identical on every hypervisor.

View file

@ -29,13 +29,6 @@ Réseau
* **La route du subnet garde la gateway pour source** (``src``) : le netns parle à ses VM depuis
la gateway, leurs réponses reviennent à l'hôte local. Depuis l'adresse d'émission, partagée par
tous les hôtes, une réponse peut partir vers un autre hôte.
* **Chaque VRF de VPC porte une route ``unreachable default`` de métrique maximale.** Sans elle,
une recherche manquée dans la VRF retombe dans la table ``main`` de l'hôte et le paquet du
locataire sort par l'underlay. Elle survit à la suppression de la VRF (aucune interface) : la
retirer explicitement au démontage.
* **``default_route: true`` sans ``gateway`` est réservé au mode ``bridge``** : en ``vxlan``, la
gateway de l'hôte n'est pas sur le subnet, la route par défaut serait inutilisable, et jointe
elle contournerait le netns et la VRF.
* ``169.254.169.254`` est centralisé dans ``metadata.ServiceIP`` — ne pas le réécrire en dur.
QEMU et VM
@ -50,8 +43,7 @@ QEMU et VM
exécuté par le processus appelant et hérite du netns posé par ``netns.Call``. Une unit
transitoire, forkée par PID 1, démarrerait dans le netns racine et ne verrait pas le tap.
* L'arrêt d'une VM ne touche **jamais** aux fichiers disque. En revanche, un ``quit`` brutal est
envoyé à l'expiration de ``times.timeout_vms_stop``. ``system_powerdown`` est renvoyé toutes les
``times.next_vms_shutdown`` : un appui ACPI arrivé avant que l'invité sache le traiter est perdu.
envoyé à l'expiration de ``dispatcher.timeout_seconds``.
Arrêt de l'agent
----------------

View file

@ -40,10 +40,7 @@ Suppression
Elle n'est autorisée que depuis ``running`` ou ``error`` — sinon **409**. Depuis ``error``, elle
est **best-effort** : les ressources système peuvent n'avoir été créées que partiellement.
Un VPC ne peut être supprimé qu'une fois tous ses subnets supprimés ou en ``deleting``, un subnet
qu'une fois toutes ses VM supprimées ou en ``deleting``. Les enfants encore en ``deleting`` sont
attendus (``times.timeout_vpc_stop``, ``times.timeout_subnet_stop``) ; si l'un d'eux passe en
``error``, la suppression du parent échoue, et le parent passe en ``error`` à son tour.
Un VPC ne peut être supprimé qu'une fois tous ses subnets supprimés.
Pas de rollback
---------------

View file

@ -172,9 +172,7 @@ seule. Le champ ``default_route`` ne choisit que son next-hop :
``default_route: true``
next-hop = le champ ``gateway`` s'il est fourni, sinon la gateway lue dans la table de routage
de l'host, à la création du subnet. Ce dernier cas est **réservé au mode** ``bridge``, où la VM
partage le L2 de cette gateway : sans ``gateway``, ``default_route: true`` est refusé (400) en
``vxlan`` et en ``public_ip``.
de l'host.
``gateway`` n'est **pas validé** par l'agent : sa joignabilité et sa cohérence avec le CIDR du
subnet relèvent de l'appelant. Fourni avec ``default_route: false``, il est ignoré.

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, unreachable default metric 4278198272
vrf-<id> VRF, table de routage = l3vni
├── 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,18 +56,8 @@ 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 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
La suppression retire d'abord la configuration de routage de FRR, puis les interfaces, puis la
VRF de FRR. Cet ordre est imposé : supprimer la VRF du noyau sous une instance BGP encore
configurée fait planter ``bgpd`` (FRR 10.7.1).
Subnet

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
``times.timeout_subnet_start``. Il n'est refusé en **422** que si le VPC est absent, en ``error``
``dispatcher.timeout_seconds``. Il n'est refusé en **422** que si le VPC est absent, en ``error``
ou en ``deleting``. Le modèle d'attente est décrit dans :doc:`/exploitation/api-agent/asynchronisme`.
2. Le subnet

View file

@ -129,10 +129,10 @@ ne change pas. Le bridge n'est créé qu'au premier démarrage, comme le reste d
**Bordures (``evpn-3hv``, #87).** ``bd1`` et ``bd2`` (``192.168.14.21`` et ``.22``) jouent les
routeurs de bordure du segment public. Ce sont des nœuds ``host`` sans agent : leur provision
(``test/e2e/topologies/provision/border.sh``) crée ``br-public``, y accroche ``vxlan-public``
(VNI 1, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway
anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:00:00:01`` (la MAC anycast
de two pour le VNI 1), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface
(``test/e2e/topologies/provision/border.sh``) crée ``br-public``, y accroche ``vxlan-66001``
(VNI 66001, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway
anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:01:01:d1`` (la MAC anycast
de two pour le VNI 66001), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface
``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur — iBGP AS 64600 vers les
deux route reflectors, ``advertise-all-vni`` — plus ``advertise-default-gw`` : la MAC et l'IP
de la gateway sont annoncées en type 2 avec la communauté *Default Gateway* (RFC 7432, §7.8 et
@ -313,11 +313,11 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé
* - ``11-validation``
- validation de l'API — refus synchrones (400, 409, 422) des VPC, subnets et VM, sans trace en base
- hv1
- #41, #57, #33, #62, #74, #81
- #41, #57, #33, #62, #74
* - ``12-etats``
- machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom
- machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom
- hv1
- #41, #84, #79
- #41
* - ``21-dhcp-two``
- DHCP par le serveur intégré (backend two) — bail, server-id, renouvellement, option 121, un serveur par subnet, démarrages simultanés
- hv1
@ -387,17 +387,17 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé
- hv1 hv2
- #57
* - ``51-l3vni``
- routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, unreachable default dans la VRF, démontage d'un VPC routé
- routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, démontage d'un VPC routé
- hv1 hv2
- #41, #81
- #41
* - ``52-migration``
- migration d'une adresse de VM entre hôtes d'un VPC routé — /32 retiré en premier, /24 en filet puis en ECMP, séquence orchestrée, 40 sources, suppression du subnet refusée tant qu'une VM l'utilise, MAC anycast hors EVPN
- hv1 hv2 hv3
- #41, #57
* - ``53-watchdog-l3``
- watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, unreachable default absente signalée, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais
- watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais
- hv1 hv3
- #41, #81
- #41
* - ``61-redemarrage-agent``
- redémarrage de l'agent avec des VM en marche — rien ne disparaît ni n'est recréé, trafic routé sans perte, DHCP et métadonnées servis, base BGP réappliquée à l'identique, ressources toujours gérées
- hv1 hv2
@ -433,7 +433,7 @@ tests ont été corrigées sur le serveur et les tests concernés rejoués. Il r
établie**. ``72-perte-switch`` n'exige donc plus que le plus prioritaire redevienne maître : il
vérifie qu'il n'y a qu'un maître, note lequel, et mesure le plus long silence après le retour ;
* une suppression de VM peut durer 300 s quand l'invité ignore l'arrêt ACPI (#79) : ``wait_state``
attend jusqu'à 480 s, au-delà du ``times.timeout_vpc_stop`` par défaut (420 s).
attend jusqu'à 360 s.
Hypothèses vérifiées en lab, à garder en tête en écrivant un test :

View file

@ -44,18 +44,14 @@ un état stable.
Trois règles pour un appelant robuste :
* **Toujours borner l'attente.** Côté agent, la section ``times`` de la configuration borne les
opérations qui attendent une transition ; l'appelant doit avoir sa propre borne.
* **Toujours borner l'attente.** Côté agent, ``dispatcher.timeout_seconds`` (300 s par défaut)
borne les opérations qui attendent une transition ; l'appelant doit avoir sa propre borne.
* **Traiter ``error`` comme terminal, pas comme un échec transitoire.** Un ``Execute`` en échec
ne se rejoue pas tout seul.
* **Savoir ce qui s'enchaîne.** Créer un subnet dont le VPC est encore en ``creating``, ou
démarrer une VM sur un subnet en ``creating``, est accepté : l'``Execute`` attend que le parent
passe ``running``, dans la limite de ``times.timeout_subnet_start`` ou ``times.timeout_vms_start`` ;
au-delà, la ressource passe en ``error``. Le refus en 422 ne vaut que pour un parent absent, en
``error`` ou en ``deleting``. À la suppression, c'est l'inverse : une VM puis son subnet, ou un
subnet puis son VPC, peuvent être supprimés d'un coup ; le parent attend que ses enfants en
``deleting`` soient supprimés (``times.timeout_subnet_stop``, ``times.timeout_vpc_stop``), et passe
en ``error`` si l'un d'eux échoue.
passe ``running``, dans la limite de ``dispatcher.timeout_seconds`` ; au-delà, la ressource passe
en ``error``. Le refus en 422 ne vaut que pour un parent absent, en ``error`` ou en ``deleting``.
Codes de retour
---------------
@ -82,8 +78,8 @@ Codes de retour
* - ``409``
- conflit d'existence ou d'état : ressource déjà créée, ou suppression depuis un état qui
ne l'autorise pas ; pour un VPC, subnets encore présents, ``l3vni`` déjà utilisée par un
autre VPC, ou ``l3vni`` demandée sans section ``bgp`` ; pour un subnet, VM qui l'utilisent
encore, ni supprimées ni en ``deleting``
autre VPC, ou ``l3vni`` demandée sans section ``bgp`` ; pour un subnet, VM non supprimées
qui l'utilisent encore
* - ``422``
- dépendance absente ou inutilisable : VPC parent d'un subnet, subnet d'une VM, absent, en
``error`` ou en ``deleting`` ; ``mode`` de subnet inconnu ; CIDR ``vxlan`` invalide ou plus

View file

@ -72,49 +72,21 @@ Exécution des commandes
count: 4
buffer_size: 100
times:
timeout_vms_stop: 300
next_vms_shutdown: 30
timeout_subnet_stop: 360
timeout_vpc_stop: 420
timeout_subnet_start: 300
timeout_vms_start: 300
poll_interval: 2
dispatcher:
timeout_seconds: 300
poll_seconds: 2
``worker.count`` est le nombre de goroutines qui exécutent les commandes ; ``buffer_size`` le
nombre de commandes en attente au-delà duquel ``Dispatch`` bloque.
La section ``times`` règle, en secondes, les attentes des commandes asynchrones :
``timeout_vms_stop``
arrêt propre d'une VM : au-delà, QEMU reçoit un ``quit`` QMP.
``next_vms_shutdown``
intervalle entre deux ``system_powerdown`` pendant cet arrêt. Un invité qui n'écoutait pas
encore l'ACPI au premier appui (firmware, chargeur de démarrage) s'éteint au suivant.
``timeout_subnet_stop``
suppression d'un subnet : attente de ses VM encore en ``deleting``.
``timeout_vpc_stop``
suppression d'un VPC : attente de ses subnets encore en ``deleting``.
``timeout_subnet_start``
création d'un subnet : attente de son VPC ``running``.
``timeout_vms_start``
création d'une VM : attente des subnets de ses interfaces ``running``.
``poll_interval``
pas de toutes ces attentes.
Chaque valeur doit être strictement positive, et ``next_vms_shutdown`` inférieur à
``timeout_vms_stop`` ; sinon l'agent refuse de démarrer. Les attentes s'enchaînent — une VM,
puis son subnet, puis le VPC : garder ``timeout_vms_stop`` < ``timeout_subnet_stop`` <
``timeout_vpc_stop`` pour qu'une suppression en cascade envoyée d'un coup aboutisse.
L'ancienne section ``dispatcher`` (``timeout_seconds``, ``poll_seconds``) n'est plus lue : restée
dans un fichier, elle est ignorée.
``dispatcher.timeout_seconds`` borne les opérations qui attendent une transition d'état, dont
l'extinction d'une VM.
.. warning::
À l'expiration de ``timeout_vms_stop``, une VM qui ne s'est pas éteinte reçoit un ``quit``
QMP — un arrêt **brutal**. Pour des charges dont l'extinction est lente (bases de données,
construction d'images), une valeur confortable évite un système de fichiers invité incohérent.
À l'expiration de ce délai, une VM qui ne s'est pas éteinte reçoit un ``quit`` QMP — un arrêt
**brutal**. Pour des charges dont l'extinction est lente (bases de données, construction
d'images), une valeur confortable évite un système de fichiers invité incohérent.
Correspondance des interfaces
-----------------------------

View file

@ -45,10 +45,7 @@ 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>``) ; route
``unreachable default`` de métrique ``4278198272`` dans la table de la VRF. Un VPC routé créé
par une version antérieure à la 0.3.0 ne l'a pas : il est signalé à chaque tick jusqu'à sa
recréation, l'agent ne la pose pas au démarrage.
``L3``, ``Up``, avec la MAC de routeur attendue (``show evpn vni <l3vni>``).
* **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,10 +117,6 @@ 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,42 +499,3 @@ func TestGetSubnet_RelayIPOnlyForVxlan(t *testing.T) {
t.Errorf("relay_ip inattendus dans la liste : %v", relays)
}
}
func TestPostSubnet_DefaultRouteWithoutGatewayOnlyForBridge(t *testing.T) {
for _, req := range []SubnetCreateRequest{
{Mode: "", CIDR: "10.0.0.0/24"},
{Mode: "vxlan", VxlanID: 1101, CIDR: "10.0.0.0/24"},
{Mode: "public_ip", InterfaceIP: "203.0.113.254", CIDR: "203.0.113.0/24"},
} {
s, db := newTestServer(t)
kv.AddInDB(db, "vpc/vpc-1/state", "running")
req.Name, req.VPC, req.DefaultRoute = "sn-1", "vpc-1", true
w := postSubnetRequest(t, s, req)
if w.Code != http.StatusBadRequest {
t.Errorf("mode %q : attendu 400, obtenu %d : %s", req.Mode, w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), "default_route without gateway is only allowed for bridge subnets") {
t.Errorf("mode %q : message %s", req.Mode, w.Body.String())
}
if _, err := kv.GetFromDB(db, "subnet/sn-1/state"); err == nil {
t.Errorf("mode %q : aucun subnet ne doit être créé", req.Mode)
}
}
}
func TestPostSubnet_DefaultRouteAccepted(t *testing.T) {
for _, req := range []SubnetCreateRequest{
{Mode: "bridge", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24"},
{Mode: "bridge", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", Gateway: "10.0.0.254"},
{Mode: "", CIDR: "10.0.0.0/24", Gateway: "10.0.0.1"},
{Mode: "vxlan", VxlanID: 1101, CIDR: "10.0.0.0/24", Gateway: "10.0.0.1"},
{Mode: "public_ip", InterfaceIP: "203.0.113.254", CIDR: "203.0.113.0/24", Gateway: "203.0.113.1"},
} {
s, db := newTestServer(t)
kv.AddInDB(db, "vpc/vpc-1/state", "running")
req.Name, req.VPC, req.DefaultRoute = "sn-1", "vpc-1", true
if w := postSubnetRequest(t, s, req); w.Code != http.StatusAccepted {
t.Errorf("mode %q gateway %q : attendu 202, obtenu %d : %s", req.Mode, req.Gateway, w.Code, w.Body.String())
}
}
}

View file

@ -78,11 +78,6 @@ func (s *Server) postSubnet(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(ErrorResponse{Error: "interface_ip is computed for vxlan subnets, do not set it"})
return
}
if req.DefaultRoute && req.Gateway == "" && req.Mode != subnet.ModeBridge {
w.WriteHeader(http.StatusBadRequest)
json.NewEncoder(w).Encode(ErrorResponse{Error: "default_route without gateway is only allowed for bridge subnets: the host gateway is not on the subnet"})
return
}
cmd := dispatcher.CreateSubnetCommand{
Name: req.Name,
VPC: req.VPC,

View file

@ -145,21 +145,4 @@ func TestLoadConfig_ExempleFourniEstValide(t *testing.T) {
if cfg.QEMU.QMPDir == "" {
t.Error("config.exemple.yml devrait définir qemu.qmp_dir")
}
if got := cfg.PublicBridge(); got != "br-public" {
t.Errorf("config.exemple.yml : bridge public %q, br-public attendu", got)
}
}
func TestLoadConfig_PublicBridgeWithoutInternetKey(t *testing.T) {
path := filepath.Join(t.TempDir(), "agent.yml")
if err := os.WriteFile(path, []byte("default_interface: br-000000\ninterfaces:\n lan: br-lan\n"), 0o600); err != nil {
t.Fatal(err)
}
cfg, err := LoadConfig(path)
if err != nil {
t.Fatalf("LoadConfig : %v", err)
}
if got := cfg.PublicBridge(); got != "br-public" {
t.Errorf("bridge public %q, br-public attendu (jamais default_interface)", got)
}
}

View file

@ -1,13 +0,0 @@
package configuration
const (
InternetInterface = "internet"
DefaultPublicBridge = "br-public"
)
func (c Config) PublicBridge() string {
if bridge := c.Interfaces[InternetInterface]; bridge != "" {
return bridge
}
return DefaultPublicBridge
}

View file

@ -1,20 +0,0 @@
package configuration
import "testing"
func TestPublicBridge(t *testing.T) {
cases := map[string]struct {
cfg Config
want string
}{
"clé absente": {Config{DefaultInterface: "br-000000"}, "br-public"},
"clé vide": {Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"internet": ""}}, "br-public"},
"clé posée": {Config{Interfaces: map[string]string{"internet": "br-wan"}}, "br-wan"},
"autres types, sans default_interface en repli": {Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"lan": "br-lan"}}, "br-public"},
}
for name, c := range cases {
if got := c.cfg.PublicBridge(); got != c.want {
t.Errorf("%s : %q, %q attendu", name, got, c.want)
}
}
}

View file

@ -24,7 +24,10 @@ type Config struct {
Count int `mapstructure:"count"`
BufferSize int `mapstructure:"buffer_size"`
} `mapstructure:"worker"`
Times Times `mapstructure:"times"`
Dispatcher struct {
TimeoutSeconds int `mapstructure:"timeout_seconds"`
PollSeconds int `mapstructure:"poll_seconds"`
} `mapstructure:"dispatcher"`
Logger struct {
Level string `mapstructure:"level"`
Debug bool `mapstructure:"debug"`
@ -70,13 +73,8 @@ func LoadConfig(path string) (*Config, error) {
v.SetDefault("prometheus.port", 9090)
v.SetDefault("worker.count", 4)
v.SetDefault("worker.buffer_size", 100)
v.SetDefault("times.timeout_vms_stop", TimeoutVMsStop)
v.SetDefault("times.next_vms_shutdown", NextVMsShutdown)
v.SetDefault("times.timeout_subnet_stop", TimeoutSubnetStop)
v.SetDefault("times.timeout_vpc_stop", TimeoutVPCStop)
v.SetDefault("times.timeout_subnet_start", TimeoutSubnetStart)
v.SetDefault("times.timeout_vms_start", TimeoutVMsStart)
v.SetDefault("times.poll_interval", PollInterval)
v.SetDefault("dispatcher.timeout_seconds", 300)
v.SetDefault("dispatcher.poll_seconds", 2)
v.SetDefault("metadata.run_dir", "/run/two/metadata")
v.SetDefault("dhcp.backend", BackendTwo)
v.SetDefault("qemu.ovmf_code_path", "/usr/share/OVMF/OVMF_CODE.fd")
@ -108,9 +106,6 @@ func LoadConfig(path string) (*Config, error) {
if err := cfg.Network.Validate(); err != nil {
return nil, fmt.Errorf("%s: %w", path, err)
}
if err := cfg.Times.Validate(); err != nil {
return nil, fmt.Errorf("%s: %w", path, err)
}
return &cfg, nil
}

View file

@ -1,64 +0,0 @@
package configuration
import (
"fmt"
"time"
)
const (
TimeoutVMsStop = 300
NextVMsShutdown = 30
TimeoutSubnetStop = 360
TimeoutVPCStop = 420
TimeoutSubnetStart = 300
TimeoutVMsStart = 300
PollInterval = 2
)
type Times struct {
TimeoutVMsStop int `mapstructure:"timeout_vms_stop"`
NextVMsShutdown int `mapstructure:"next_vms_shutdown"`
TimeoutSubnetStop int `mapstructure:"timeout_subnet_stop"`
TimeoutVPCStop int `mapstructure:"timeout_vpc_stop"`
TimeoutSubnetStart int `mapstructure:"timeout_subnet_start"`
TimeoutVMsStart int `mapstructure:"timeout_vms_start"`
PollInterval int `mapstructure:"poll_interval"`
}
func seconds(value, fallback int) time.Duration {
if value == 0 {
value = fallback
}
return time.Duration(value) * time.Second
}
func (t Times) VMsStop() time.Duration { return seconds(t.TimeoutVMsStop, TimeoutVMsStop) }
func (t Times) VMsShutdown() time.Duration { return seconds(t.NextVMsShutdown, NextVMsShutdown) }
func (t Times) SubnetStop() time.Duration { return seconds(t.TimeoutSubnetStop, TimeoutSubnetStop) }
func (t Times) VPCStop() time.Duration { return seconds(t.TimeoutVPCStop, TimeoutVPCStop) }
func (t Times) SubnetStart() time.Duration { return seconds(t.TimeoutSubnetStart, TimeoutSubnetStart) }
func (t Times) VMsStart() time.Duration { return seconds(t.TimeoutVMsStart, TimeoutVMsStart) }
func (t Times) Poll() time.Duration { return seconds(t.PollInterval, PollInterval) }
func (t Times) Validate() error {
for _, f := range []struct {
key string
value int
}{
{"timeout_vms_stop", t.TimeoutVMsStop},
{"next_vms_shutdown", t.NextVMsShutdown},
{"timeout_subnet_stop", t.TimeoutSubnetStop},
{"timeout_vpc_stop", t.TimeoutVPCStop},
{"timeout_subnet_start", t.TimeoutSubnetStart},
{"timeout_vms_start", t.TimeoutVMsStart},
{"poll_interval", t.PollInterval},
} {
if f.value <= 0 {
return fmt.Errorf("times.%s %d must be a positive number of seconds", f.key, f.value)
}
}
if t.NextVMsShutdown >= t.TimeoutVMsStop {
return fmt.Errorf("times.next_vms_shutdown %d must be below times.timeout_vms_stop %d", t.NextVMsShutdown, t.TimeoutVMsStop)
}
return nil
}

View file

@ -1,95 +0,0 @@
package configuration
import (
"strings"
"testing"
"time"
)
func TestLoadConfig_TimesDefauts(t *testing.T) {
cfg, err := LoadConfig(writeYAML(t, ""))
if err != nil {
t.Fatalf("LoadConfig a échoué : %v", err)
}
want := Times{
TimeoutVMsStop: 300,
NextVMsShutdown: 30,
TimeoutSubnetStop: 360,
TimeoutVPCStop: 420,
TimeoutSubnetStart: 300,
TimeoutVMsStart: 300,
PollInterval: 2,
}
if cfg.Times != want {
t.Errorf("times par défaut : %+v, attendu %+v", cfg.Times, want)
}
}
func TestLoadConfig_TimesValeursExplicites(t *testing.T) {
cfg, err := LoadConfig(writeYAML(t, "times:\n timeout_vms_stop: 600\n next_vms_shutdown: 10\n timeout_subnet_stop: 700\n timeout_vpc_stop: 800\n timeout_subnet_start: 50\n timeout_vms_start: 60\n poll_interval: 1\n"))
if err != nil {
t.Fatalf("LoadConfig a échoué : %v", err)
}
want := Times{600, 10, 700, 800, 50, 60, 1}
if cfg.Times != want {
t.Errorf("times : %+v, attendu %+v", cfg.Times, want)
}
}
func TestLoadConfig_AncienneSectionDispatcherIgnoree(t *testing.T) {
cfg, err := LoadConfig(writeYAML(t, "dispatcher:\n timeout_seconds: 900\n poll_seconds: 7\n"))
if err != nil {
t.Fatalf("une section dispatcher restante ne doit pas empêcher le démarrage : %v", err)
}
if cfg.Times.TimeoutVMsStop != 300 || cfg.Times.PollInterval != 2 {
t.Errorf("dispatcher.* ne doit rien changer : %+v", cfg.Times)
}
}
func TestLoadConfig_TimesInvalidesRefuses(t *testing.T) {
for _, c := range []struct{ yaml, msg string }{
{"times:\n timeout_vms_stop: 0\n", "times.timeout_vms_stop 0 must be a positive number of seconds"},
{"times:\n next_vms_shutdown: -1\n", "times.next_vms_shutdown -1 must be a positive number of seconds"},
{"times:\n timeout_subnet_stop: 0\n", "times.timeout_subnet_stop 0"},
{"times:\n timeout_vpc_stop: 0\n", "times.timeout_vpc_stop 0"},
{"times:\n timeout_subnet_start: 0\n", "times.timeout_subnet_start 0"},
{"times:\n timeout_vms_start: 0\n", "times.timeout_vms_start 0"},
{"times:\n poll_interval: 0\n", "times.poll_interval 0"},
{"times:\n next_vms_shutdown: 300\n", "times.next_vms_shutdown 300 must be below times.timeout_vms_stop 300"},
} {
if _, err := LoadConfig(writeYAML(t, c.yaml)); err == nil || !strings.Contains(err.Error(), c.msg) {
t.Errorf("%q : erreur %v, attendu %q", c.yaml, err, c.msg)
}
}
if _, err := LoadConfig(writeYAML(t, "times:\n next_vms_shutdown: 299\n")); err != nil {
t.Errorf("next_vms_shutdown 299 sous timeout_vms_stop 300 : %v", err)
}
}
func TestTimesDurees(t *testing.T) {
var zero Times
cases := []struct {
name string
got, want time.Duration
}{
{"VMsStop", zero.VMsStop(), 300 * time.Second},
{"VMsShutdown", zero.VMsShutdown(), 30 * time.Second},
{"SubnetStop", zero.SubnetStop(), 360 * time.Second},
{"VPCStop", zero.VPCStop(), 420 * time.Second},
{"SubnetStart", zero.SubnetStart(), 300 * time.Second},
{"VMsStart", zero.VMsStart(), 300 * time.Second},
{"Poll", zero.Poll(), 2 * time.Second},
}
for _, c := range cases {
if c.got != c.want {
t.Errorf("Times{}.%s() = %v, attendu %v", c.name, c.got, c.want)
}
}
set := Times{11, 12, 13, 14, 15, 16, 17}
got := []time.Duration{set.VMsStop(), set.VMsShutdown(), set.SubnetStop(), set.VPCStop(), set.SubnetStart(), set.VMsStart(), set.Poll()}
for i, d := range got {
if want := time.Duration(11+i) * time.Second; d != want {
t.Errorf("durée %d = %v, attendu %v", i, d, want)
}
}
}

View file

@ -1,7 +1,6 @@
package dispatcher
import (
"errors"
"fmt"
"sort"
"strconv"
@ -94,21 +93,23 @@ func (c CreateSubnetCommand) Prepare(db *badger.DB, cfg *configuration.Config) e
}
func (c CreateSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
err := waitUntil(cfg.Times.SubnetStart(), cfg.Times.Poll(), func() (bool, error) {
timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second)
for {
vpcState, err := state.Get(db, "vpc/"+c.VPC)
if err != nil {
return false, fmt.Errorf("vpc %q not found while waiting", c.VPC)
return fmt.Errorf("vpc %q not found while waiting", c.VPC)
}
if vpcState != state.Running && vpcState != state.Creating {
return false, fmt.Errorf("vpc %q is %s, cannot create subnet %q", c.VPC, vpcState, c.Name)
if vpcState == state.Running {
break
}
if vpcState != state.Creating {
return fmt.Errorf("vpc %q is %s, cannot create subnet %q", c.VPC, vpcState, c.Name)
}
select {
case <-timeout:
return fmt.Errorf("timed out waiting for vpc %q to be running", c.VPC)
case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second):
}
return vpcState == state.Running, nil
})
if errors.Is(err, errWaitTimeout) {
return fmt.Errorf("timed out waiting for vpc %q to be running", c.VPC)
}
if err != nil {
return err
}
return subnet.CreateSubnet(db, c.Name, cfg)
}
@ -131,41 +132,12 @@ func (c DeleteSubnetCommand) Prepare(db *badger.DB, _ *configuration.Config) err
if err != nil {
return err
}
var blocking []string
for _, name := range vms {
if s, err := state.Get(db, "vm/"+name); err != nil || s != state.Deleting {
blocking = append(blocking, name)
}
}
if len(blocking) > 0 {
return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(blocking, ", "))
if len(vms) > 0 {
return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(vms, ", "))
}
return state.Set(db, c.Key(), state.Deleting)
}
func waitVMsDeleted(db *badger.DB, subnetName string, timeout, poll time.Duration) error {
err := waitUntil(timeout, poll, func() (bool, error) {
vms, err := vmsUsingSubnet(db, subnetName)
if err != nil {
return false, err
}
for _, name := range vms {
s, err := state.Get(db, "vm/"+name)
if err != nil {
continue
}
if s != state.Deleting {
return false, fmt.Errorf("vm %q is %s, subnet %q cannot be deleted", name, s, subnetName)
}
}
return len(vms) == 0, nil
})
if errors.Is(err, errWaitTimeout) {
return fmt.Errorf("timed out waiting for the vms of subnet %q to be deleted", subnetName)
}
return err
}
func vmsUsingSubnet(db *badger.DB, subnetName string) ([]string, error) {
entries, err := kv.ListByPrefix(db, "vm/")
if err != nil {
@ -187,9 +159,6 @@ func vmsUsingSubnet(db *badger.DB, subnetName string) ([]string, error) {
}
func (c DeleteSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
if err := waitVMsDeleted(db, c.Name, cfg.Times.SubnetStop(), cfg.Times.Poll()); err != nil {
return err
}
if err := subnet.DeleteSubnet(db, c.Name, cfg); err != nil {
return err
}

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-c`) {
if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-b, i-c`) {
t.Fatalf("erreur %v", err)
}
if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "running" {

View file

@ -1,7 +1,6 @@
package dispatcher
import (
"errors"
"fmt"
"math/rand"
"strconv"
@ -152,23 +151,24 @@ func allocateMetadataPort(db *badger.DB) (int, error) {
}
func (c StartVMCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
timeout := time.Now().Add(cfg.Times.VMsStart())
timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second)
for _, n := range c.NICs {
err := waitUntil(time.Until(timeout), cfg.Times.Poll(), func() (bool, error) {
for {
subnetState, err := state.Get(db, "subnet/"+n.Subnet)
if err != nil {
return false, fmt.Errorf("subnet %q not found while waiting", n.Subnet)
return fmt.Errorf("subnet %q not found while waiting", n.Subnet)
}
if subnetState != state.Running && subnetState != state.Creating {
return false, fmt.Errorf("subnet %q is %s, cannot start vm %q", n.Subnet, subnetState, c.Name)
if subnetState == state.Running {
break
}
if subnetState != state.Creating {
return fmt.Errorf("subnet %q is %s, cannot start vm %q", n.Subnet, subnetState, c.Name)
}
select {
case <-timeout:
return fmt.Errorf("timed out waiting for subnet %q to be running", n.Subnet)
case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second):
}
return subnetState == state.Running, nil
})
if errors.Is(err, errWaitTimeout) {
return fmt.Errorf("timed out waiting for subnet %q to be running", n.Subnet)
}
if err != nil {
return err
}
}
return vm.StartVM(db, c.Name, cfg)

View file

@ -1,7 +1,6 @@
package dispatcher
import (
"errors"
"fmt"
"net"
"strconv"
@ -130,8 +129,31 @@ func (c DeleteVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error
}
func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
if err := waitSubnetsDeleted(db, c.Name, cfg.Times.VPCStop(), cfg.Times.Poll()); err != nil {
return err
timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second)
for {
entries, err := kv.ListByPrefix(db, "subnet/")
if err != nil {
return fmt.Errorf("failed to list subnets: %w", err)
}
pending := false
for key, value := range entries {
if strings.HasSuffix(key, "/vpc") && value == c.Name {
subnetName := strings.Split(key, "/")[1]
s, _ := state.Get(db, "subnet/"+subnetName)
if s == state.Deleting {
pending = true
break
}
}
}
if !pending {
break
}
select {
case <-timeout:
return fmt.Errorf("timed out waiting for subnets of vpc %q to be deleted", c.Name)
case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second):
}
}
if err := vpc.DeleteVPC(db, c.Name); err != nil {
return err
@ -145,35 +167,3 @@ func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) erro
}
return nil
}
func waitSubnetsDeleted(db *badger.DB, vpcName string, timeout, poll time.Duration) error {
err := waitUntil(timeout, poll, func() (bool, error) {
entries, err := kv.ListByPrefix(db, "subnet/")
if err != nil {
return false, fmt.Errorf("failed to list subnets: %w", err)
}
pending := false
for key, value := range entries {
if !strings.HasSuffix(key, "/vpc") || value != vpcName {
continue
}
subnetName := strings.Split(key, "/")[1]
s, err := state.Get(db, "subnet/"+subnetName)
if err != nil {
continue
}
switch s {
case state.Deleted:
case state.Deleting:
pending = true
default:
return false, fmt.Errorf("subnet %q is %s, vpc %q cannot be deleted", subnetName, s, vpcName)
}
}
return !pending, nil
})
if errors.Is(err, errWaitTimeout) {
return fmt.Errorf("timed out waiting for subnets of vpc %q to be deleted", vpcName)
}
return err
}

View file

@ -1,26 +0,0 @@
package dispatcher
import (
"errors"
"time"
)
var errWaitTimeout = errors.New("timed out")
func waitUntil(timeout, poll time.Duration, done func() (bool, error)) error {
deadline := time.After(timeout)
for {
ok, err := done()
if err != nil {
return err
}
if ok {
return nil
}
select {
case <-deadline:
return errWaitTimeout
case <-time.After(poll):
}
}
}

View file

@ -1,168 +0,0 @@
package dispatcher
import (
"errors"
"strings"
"testing"
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/pkg/db/kv"
)
func TestWaitUntil(t *testing.T) {
calls := 0
err := waitUntil(time.Second, time.Millisecond, func() (bool, error) {
calls++
return calls == 3, nil
})
if err != nil || calls != 3 {
t.Errorf("err %v, %d appels, attendu fin au troisième", err, calls)
}
if err := waitUntil(30*time.Millisecond, 5*time.Millisecond, func() (bool, error) { return false, nil }); !errors.Is(err, errWaitTimeout) {
t.Errorf("délai dépassé : %v", err)
}
boom := errors.New("boom")
calls = 0
err = waitUntil(time.Second, time.Millisecond, func() (bool, error) {
calls++
return false, boom
})
if !errors.Is(err, boom) || calls != 1 {
t.Errorf("erreur %v après %d appels, attendu boom au premier", err, calls)
}
}
func TestDeleteSubnetCommand_Prepare_AcceptsVMsBeingDeleted(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-a/state", "running")
kv.AddInDB(db, "vm/i-a/state", "deleting")
kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a")
kv.AddInDB(db, "vm/i-gone/state", "deleted")
kv.AddInDB(db, "vm/i-gone/nic/0/subnet", "sn-a")
if err := (DeleteSubnetCommand{Name: "sn-a"}).Prepare(db, nil); err != nil {
t.Fatalf("VM en deleting : %v", err)
}
if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "deleting" {
t.Errorf("état %q, attendu deleting", s)
}
}
func TestDeleteSubnetCommand_Prepare_ListsOnlyTheVMsNotBeingDeleted(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-a/state", "running")
kv.AddInDB(db, "vm/i-a/state", "deleting")
kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a")
kv.AddInDB(db, "vm/i-b/state", "running")
kv.AddInDB(db, "vm/i-b/nic/0/subnet", "sn-a")
err := DeleteSubnetCommand{Name: "sn-a"}.Prepare(db, nil)
if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-b`) || strings.Contains(err.Error(), "i-a") {
t.Fatalf("erreur %v", err)
}
}
func TestWaitVMsDeleted_ReturnsOnceTheVMsAreGone(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vm/i-a/state", "deleting")
kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a")
kv.AddInDB(db, "vm/i-other/state", "running")
kv.AddInDB(db, "vm/i-other/nic/0/subnet", "sn-b")
go func() {
time.Sleep(30 * time.Millisecond)
kv.DeleteInDB(db, "vm/i-a")
}()
if err := waitVMsDeleted(db, "sn-a", 2*time.Second, 5*time.Millisecond); err != nil {
t.Fatalf("attente : %v", err)
}
}
func TestWaitVMsDeleted_FailsWhenAVMEndsInError(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vm/i-a/state", "deleting")
kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a")
go func() {
time.Sleep(20 * time.Millisecond)
kv.AddInDB(db, "vm/i-a/state", "error")
}()
err := waitVMsDeleted(db, "sn-a", 2*time.Second, 5*time.Millisecond)
if err == nil || !strings.Contains(err.Error(), `vm "i-a" is error, subnet "sn-a" cannot be deleted`) {
t.Fatalf("erreur %v", err)
}
}
func TestWaitVMsDeleted_TimesOut(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vm/i-a/state", "deleting")
kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a")
err := waitVMsDeleted(db, "sn-a", 30*time.Millisecond, 5*time.Millisecond)
if err == nil || err.Error() != `timed out waiting for the vms of subnet "sn-a" to be deleted` {
t.Fatalf("erreur %v", err)
}
}
func TestWaitSubnetsDeleted_ReturnsOnceTheSubnetsAreGone(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-a/state", "deleting")
kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a")
kv.AddInDB(db, "subnet/sn-b/state", "deleted")
kv.AddInDB(db, "subnet/sn-b/vpc", "vp-a")
kv.AddInDB(db, "subnet/sn-x/state", "running")
kv.AddInDB(db, "subnet/sn-x/vpc", "vp-x")
go func() {
time.Sleep(30 * time.Millisecond)
kv.DeleteInDB(db, "subnet/sn-a")
}()
if err := waitSubnetsDeleted(db, "vp-a", 2*time.Second, 5*time.Millisecond); err != nil {
t.Fatalf("attente : %v", err)
}
}
func TestWaitSubnetsDeleted_FailsWhenASubnetEndsInError(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-a/state", "deleting")
kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a")
go func() {
time.Sleep(20 * time.Millisecond)
kv.AddInDB(db, "subnet/sn-a/state", "error")
}()
err := waitSubnetsDeleted(db, "vp-a", 2*time.Second, 5*time.Millisecond)
if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is error, vpc "vp-a" cannot be deleted`) {
t.Fatalf("erreur %v", err)
}
}
func TestWaitSubnetsDeleted_TimesOut(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-a/state", "deleting")
kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a")
err := waitSubnetsDeleted(db, "vp-a", 30*time.Millisecond, 5*time.Millisecond)
if err == nil || err.Error() != `timed out waiting for subnets of vpc "vp-a" to be deleted` {
t.Fatalf("erreur %v", err)
}
}
func TestDeleteSubnetCommand_Execute_FailsBeforeTouchingTheHostWhenAVMIsInError(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-a/state", "deleting")
kv.AddInDB(db, "vm/i-a/state", "error")
kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a")
cfg := &configuration.Config{Times: configuration.Times{TimeoutSubnetStop: 1, PollInterval: 1}}
err := DeleteSubnetCommand{Name: "sn-a"}.Execute(db, cfg)
if err == nil || err.Error() != `vm "i-a" is error, subnet "sn-a" cannot be deleted` {
t.Fatalf("erreur %v", err)
}
}
func TestDeleteVPCCommand_Execute_FailsBeforeTouchingTheHostWhenASubnetIsInError(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vp-a/state", "deleting")
kv.AddInDB(db, "subnet/sn-a/state", "error")
kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a")
cfg := &configuration.Config{Times: configuration.Times{TimeoutVPCStop: 1, PollInterval: 1}}
err := DeleteVPCCommand{Name: "vp-a"}.Execute(db, cfg)
if err == nil || err.Error() != `subnet "sn-a" is error, vpc "vp-a" cannot be deleted` {
t.Fatalf("erreur %v", err)
}
}

View file

@ -23,8 +23,6 @@ type host interface {
DeleteLink(name string) error
TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error
TableRouteDel(table uint32, dst *net.IPNet) error
TableUnreachableDefault(table uint32) error
TableUnreachableDefaultDel(table uint32) error
ApplyVRF(v frr.VRF) error
WithdrawVRF(v frr.VRF) error
RemoveVRF(v frr.VRF) error
@ -89,14 +87,6 @@ func (system) TableRouteDel(table uint32, dst *net.IPNet) error {
return netif.RouteDelIfExists(int(table), dst)
}
func (system) TableUnreachableDefault(table uint32) error {
return netif.RouteReplaceUnreachableDefault(int(table), UnreachableMetric)
}
func (system) TableUnreachableDefaultDel(table uint32) error {
return netif.RouteDelUnreachableDefaultIfExists(int(table), UnreachableMetric)
}
func (s system) ApplyVRF(v frr.VRF) error { return s.frr.ApplyVRF(v) }
func (s system) WithdrawVRF(v frr.VRF) error { return s.frr.WithdrawVRF(v) }

View file

@ -14,8 +14,6 @@ import (
"github.com/dgraph-io/badger/v4"
)
const UnreachableMetric = 4278198272
var (
transitHost = &net.IPNet{IP: net.IPv4(169, 254, 0, 1).To4(), Mask: net.CIDRMask(30, 32)}
transitNetns = &net.IPNet{IP: net.IPv4(169, 254, 0, 2).To4(), Mask: net.CIDRMask(30, 32)}
@ -86,7 +84,6 @@ func createL3(h host, cfg *configuration.Config, v l3VPC) error {
run func() error
}{
{"create " + v.vrf(), func() error { return h.CreateVRF(v.vrf(), v.vni) }},
{"unreachable default in " + v.vrf(), func() error { return h.TableUnreachableDefault(v.vni) }},
{"create " + v.bridge(), func() error { return h.CreateBridge(v.bridge(), mtu, rmac) }},
{"attach " + v.bridge(), func() error { return h.SetMaster(v.bridge(), v.vrf()) }},
{"create " + v.vxlan(), func() error { return h.CreateVxlan(v.vxlan(), int(v.vni), cfg.DefaultInterface, mtu) }},
@ -126,9 +123,6 @@ func deleteL3(h host, v l3VPC) error {
return fmt.Errorf("l3vni %d: delete %s: %w", v.vni, link, err)
}
}
if err := h.TableUnreachableDefaultDel(v.vni); err != nil {
return fmt.Errorf("l3vni %d: delete unreachable default from table %d: %w", v.vni, v.vni, err)
}
if err := h.RemoveVRF(frrVRF); err != nil {
return fmt.Errorf("l3vni %d: remove frr vrf: %w", v.vni, err)
}

View file

@ -83,14 +83,6 @@ func (f *fakeHost) TableRouteDel(table uint32, dst *net.IPNet) error {
return f.record(fmt.Sprintf("table %d del %s", table, dst))
}
func (f *fakeHost) TableUnreachableDefault(table uint32) error {
return f.record(fmt.Sprintf("table %d unreachable default", table))
}
func (f *fakeHost) TableUnreachableDefaultDel(table uint32) error {
return f.record(fmt.Sprintf("table %d del unreachable default", table))
}
func (f *fakeHost) ApplyVRF(v frr.VRF) error {
return f.record(fmt.Sprintf("frr apply asn=%d id=%s vni=%d vtep=%s supernet=%s", v.ASN, v.ID, v.L3VNI, v.VTEP, v.Supernet))
}
@ -129,7 +121,6 @@ func TestCreateL3FollowsTheLabRecipe(t *testing.T) {
want := []string{
"vtep br-000000",
"vrf vrf-s7 table 2700",
"table 2700 unreachable default",
"bridge brl3-s7 mtu 1450 mac 02:02:c0:a8:0e:0b",
"master brl3-s7 vrf-s7",
"vxlan vxl3-s7 id 2700 dev br-000000 mtu 1450",
@ -188,7 +179,6 @@ func TestDeleteL3WithdrawsFRRThenTheKernelThenTheVRF(t *testing.T) {
"del vxl3-s7",
"del brl3-s7",
"del vrf-s7",
"table 2700 del unreachable default",
"frr remove asn=0 id=s7 vni=0",
}
if !reflect.DeepEqual(f.calls, want) {
@ -219,39 +209,9 @@ func TestDeleteL3KeepsTheFRRVRFWhenAKernelLinkCannotBeDeleted(t *testing.T) {
}
}
func TestCreateL3LeavesNoVRFWithoutItsUnreachableDefault(t *testing.T) {
f := &fakeHost{fail: map[string]error{"table 2700 unreachable default": errors.New("operation not permitted")}}
err := createL3(f, bgpConfig(), labL3(t))
if err == nil || !strings.Contains(err.Error(), "l3vni 2700: unreachable default in vrf-s7: operation not permitted") {
t.Errorf("erreur %v", err)
}
if last := f.calls[len(f.calls)-1]; last != "table 2700 unreachable default" {
t.Errorf("appels après l'échec : %q", f.calls)
}
}
func TestDeleteL3KeepsTheFRRVRFWhenTheUnreachableDefaultCannotBeDeleted(t *testing.T) {
f := &fakeHost{fail: map[string]error{"table 2700 del unreachable default": errors.New("operation not permitted")}}
err := deleteL3(f, labL3(t))
if err == nil || !strings.Contains(err.Error(), "delete unreachable default from table 2700") {
t.Errorf("erreur %v", err)
}
for _, c := range f.calls {
if strings.HasPrefix(c, "frr remove") {
t.Errorf("étape exécutée après l'échec : %q", f.calls)
}
}
}
func TestUnreachableMetricIsTheHighestRecommendedByTheKernel(t *testing.T) {
if UnreachableMetric != 4278198272 {
t.Errorf("UnreachableMetric = %d", UnreachableMetric)
}
}
func TestDeleteL3DoesNotDependOnTheAgentBGPSection(t *testing.T) {
f := &fakeHost{}
if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 7 {
if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 6 {
t.Errorf("erreur %v, appels %q", err, f.calls)
}
}

View file

@ -46,21 +46,3 @@ func LinkMTU(name string) (int, error) {
}
return link.Attrs().MTU, nil
}
func BridgeVxlanPorts(bridge string) ([]string, error) {
br, err := netlink.LinkByName(bridge)
if err != nil {
return nil, err
}
links, err := netlink.LinkList()
if err != nil {
return nil, err
}
var ports []string
for _, l := range links {
if l.Attrs().MasterIndex == br.Attrs().Index && l.Type() == "vxlan" {
ports = append(ports, l.Attrs().Name)
}
}
return ports, nil
}

View file

@ -3,16 +3,11 @@
package netif
import (
"errors"
"net"
"syscall"
"github.com/vishvananda/netlink"
"golang.org/x/sys/unix"
)
var defaultIPv4 = &net.IPNet{IP: net.IPv4zero.To4(), Mask: net.CIDRMask(0, 32)}
func RouteAdd(iface string, subnet *net.IPNet) error {
return RouteAddFrom(iface, subnet, nil)
}
@ -50,44 +45,3 @@ func TableRoutesVia(table int, iface string) ([]*net.IPNet, error) {
}
return dsts, nil
}
func unreachableDefault(table, metric int) *netlink.Route {
return &netlink.Route{
Dst: defaultIPv4,
Table: table,
Type: unix.RTN_UNREACHABLE,
Priority: metric,
}
}
func RouteReplaceUnreachableDefault(table, metric int) error {
return netlink.RouteReplace(unreachableDefault(table, metric))
}
func RouteDelUnreachableDefaultIfExists(table, metric int) error {
if err := netlink.RouteDel(unreachableDefault(table, metric)); err != nil && !errors.Is(err, syscall.ESRCH) {
return err
}
return nil
}
func HasUnreachableDefault(table, metric int) (bool, error) {
routes, err := netlink.RouteListFiltered(netlink.FAMILY_V4, &netlink.Route{
Table: table,
Type: unix.RTN_UNREACHABLE,
}, netlink.RT_FILTER_TABLE|netlink.RT_FILTER_TYPE)
if err != nil {
return false, err
}
for _, r := range routes {
if r.Priority == metric && (r.Dst == nil || isDefault(r.Dst)) {
return true, nil
}
}
return false, nil
}
func isDefault(dst *net.IPNet) bool {
ones, _ := dst.Mask.Size()
return ones == 0
}

View file

@ -18,15 +18,3 @@ func RouteAddFrom(_ string, _ *net.IPNet, _ net.IP) error {
func TableRoutesVia(_ int, _ string) ([]*net.IPNet, error) {
return nil, errors.New("route listing is only implemented on linux")
}
func RouteReplaceUnreachableDefault(_, _ int) error {
return errors.New("not supported on this platform")
}
func RouteDelUnreachableDefaultIfExists(_, _ int) error {
return errors.New("not supported on this platform")
}
func HasUnreachableDefault(_, _ int) (bool, error) {
return false, errors.New("route listing is only implemented on linux")
}

View file

@ -1,10 +1,7 @@
package vm
import (
"encoding/json"
"errors"
"fmt"
"io/fs"
"os"
"path/filepath"
"time"
@ -50,14 +47,16 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error {
if _, err := os.Stat(socketPath); err == nil {
// socket présent : tenter l'arrêt gracieux
shutdownQEMU(qmp.Send, socketPath, cfg.Times.VMsStop(), cfg.Times.VMsShutdown(), cfg.Times.Poll())
if _, err := qmp.Send(socketPath, []string{`{"execute":"system_powerdown"}`}); err == nil {
waitQMPDead(socketPath,
time.Duration(cfg.Dispatcher.TimeoutSeconds)*time.Second,
time.Duration(cfg.Dispatcher.PollSeconds)*time.Second,
)
}
// connexion QMP échouée : QEMU déjà mort
}
// socket absent ou QEMU déjà arrêté : cleanup direct
if err := removeQEMUSockets(cfg, name); err != nil {
return err
}
if err := netns.Call(nic.vpcName, func() error {
for _, n := range d.nics {
if err := iptables.DeleteMetadataRedirect(n.ip, nic.interfaceIP, d.metadataPort); err != nil {
@ -91,16 +90,6 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error {
return state.Set(db, "vm/"+name, state.Deleted)
}
func removeQEMUSockets(cfg *configuration.Config, name string) error {
for _, dir := range []string{cfg.QEMU.SerialDir, cfg.QEMU.MonitorDir, cfg.QEMU.QMPDir} {
path := filepath.Join(dir, name+".sock")
if err := os.Remove(path); err != nil && !errors.Is(err, fs.ErrNotExist) {
return fmt.Errorf("remove qemu socket: %w", err)
}
}
return nil
}
func removeDHCPFiles(d vmData, name string, backend dhcpbackend.Backend) error {
for _, f := range dhcpReservations(d) {
if err := backend.DelVM(f.subnet, name, f.reservations); err != nil {
@ -110,31 +99,15 @@ func removeDHCPFiles(d vmData, name string, backend dhcpbackend.Backend) error {
return nil
}
type qmpSender func(socketPath string, commands []string) ([]json.RawMessage, error)
const (
qmpPowerdown = `{"execute":"system_powerdown"}`
qmpQuit = `{"execute":"quit"}`
)
func shutdownQEMU(send qmpSender, socketPath string, timeout, resend, poll time.Duration) {
if _, err := send(socketPath, []string{qmpPowerdown}); err != nil {
return
}
deadline := time.After(timeout)
again := time.NewTicker(resend)
defer again.Stop()
func waitQMPDead(socketPath string, timeout, poll time.Duration) {
timer := time.After(timeout)
for {
select {
case <-deadline:
send(socketPath, []string{qmpQuit})
case <-timer:
qmp.Send(socketPath, []string{`{"execute":"quit"}`})
return
case <-again.C:
if _, err := send(socketPath, []string{qmpPowerdown}); err != nil {
return
}
case <-time.After(poll):
if _, err := send(socketPath, nil); err != nil {
if _, err := qmp.Send(socketPath, nil); err != nil {
return
}
}

View file

@ -1,86 +0,0 @@
package vm
import (
"os"
"path/filepath"
"strings"
"testing"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
)
func socketDirs(t *testing.T) *configuration.Config {
t.Helper()
root, err := os.MkdirTemp("", "sock")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { os.RemoveAll(root) })
cfg := &configuration.Config{}
cfg.QEMU.SerialDir = filepath.Join(root, "serial")
cfg.QEMU.MonitorDir = filepath.Join(root, "monitor")
cfg.QEMU.QMPDir = filepath.Join(root, "qmp")
for _, dir := range []string{cfg.QEMU.SerialDir, cfg.QEMU.MonitorDir, cfg.QEMU.QMPDir} {
if err := os.Mkdir(dir, 0755); err != nil {
t.Fatal(err)
}
}
return cfg
}
func leave(t *testing.T, path string) {
t.Helper()
if err := os.WriteFile(path, nil, 0600); err != nil {
t.Fatal(err)
}
}
func TestRemoveQEMUSockets_RemovesTheThreeSocketsOfTheVM(t *testing.T) {
cfg := socketDirs(t)
sockets := []string{
filepath.Join(cfg.QEMU.SerialDir, "t12-err.sock"),
filepath.Join(cfg.QEMU.MonitorDir, "t12-err.sock"),
filepath.Join(cfg.QEMU.QMPDir, "t12-err.sock"),
}
for _, s := range sockets {
leave(t, s)
}
other := filepath.Join(cfg.QEMU.MonitorDir, "t12-ok.sock")
leave(t, other)
if err := removeQEMUSockets(cfg, "t12-err"); err != nil {
t.Fatal(err)
}
for _, s := range sockets {
if _, err := os.Lstat(s); !os.IsNotExist(err) {
t.Errorf("%s laissé (%v)", s, err)
}
}
if _, err := os.Lstat(other); err != nil {
t.Errorf("socket d'une autre VM retiré : %v", err)
}
}
func TestRemoveQEMUSockets_AbsentSocketsAreNotAnError(t *testing.T) {
cfg := socketDirs(t)
leave(t, filepath.Join(cfg.QEMU.MonitorDir, "t12-err.sock"))
if err := removeQEMUSockets(cfg, "t12-err"); err != nil {
t.Errorf("sockets serial et qmp absents : %v", err)
}
if err := removeQEMUSockets(cfg, "t12-err"); err != nil {
t.Errorf("second passage : %v", err)
}
}
func TestRemoveQEMUSockets_ReportsAFailedRemoval(t *testing.T) {
cfg := socketDirs(t)
blocked := filepath.Join(cfg.QEMU.QMPDir, "t12-err.sock")
if err := os.Mkdir(blocked, 0755); err != nil {
t.Fatal(err)
}
leave(t, filepath.Join(blocked, "x"))
err := removeQEMUSockets(cfg, "t12-err")
if err == nil || !strings.Contains(err.Error(), "remove qemu socket") || !strings.Contains(err.Error(), blocked) {
t.Errorf("erreur %v, attendu l'échec de suppression de %s", err, blocked)
}
}

View file

@ -1,102 +0,0 @@
package vm
import (
"encoding/json"
"errors"
"sync"
"testing"
"time"
)
type fakeQEMU struct {
mu sync.Mutex
calls []string
dieAfter int
powerdown int
dead bool
}
func (f *fakeQEMU) send(_ string, commands []string) ([]json.RawMessage, error) {
f.mu.Lock()
defer f.mu.Unlock()
call := "ping"
if len(commands) > 0 {
call = commands[0]
}
f.calls = append(f.calls, call)
if f.dead {
return nil, errors.New("qmp dial: connection refused")
}
switch call {
case qmpPowerdown:
f.powerdown++
if f.dieAfter > 0 && f.powerdown >= f.dieAfter {
f.dead = true
}
case qmpQuit:
f.dead = true
}
return nil, nil
}
func (f *fakeQEMU) count(call string) int {
f.mu.Lock()
defer f.mu.Unlock()
n := 0
for _, c := range f.calls {
if c == call {
n++
}
}
return n
}
func TestShutdownQEMU_ResendsPowerdownUntilTheGuestListens(t *testing.T) {
f := &fakeQEMU{dieAfter: 3}
start := time.Now()
shutdownQEMU(f.send, "qmp.sock", 5*time.Second, 50*time.Millisecond, 10*time.Millisecond)
if d := time.Since(start); d > 2*time.Second {
t.Errorf("arrêt en %v : le renvoi aurait dû l'obtenir bien avant le délai", d)
}
if n := f.count(qmpPowerdown); n != 3 {
t.Errorf("%d system_powerdown envoyés, attendu 3 (le troisième est entendu)", n)
}
if n := f.count(qmpQuit); n != 0 {
t.Errorf("quit envoyé alors que l'invité s'est arrêté : %q", f.calls)
}
}
func TestShutdownQEMU_QuitsAtTheDeadline(t *testing.T) {
f := &fakeQEMU{}
start := time.Now()
shutdownQEMU(f.send, "qmp.sock", 200*time.Millisecond, 60*time.Millisecond, 10*time.Millisecond)
d := time.Since(start)
if d < 200*time.Millisecond || d > 2*time.Second {
t.Errorf("arrêt en %v, attendu au délai de 200ms", d)
}
if n := f.count(qmpPowerdown); n < 3 {
t.Errorf("%d system_powerdown envoyés en 200ms avec un renvoi toutes les 60ms", n)
}
if n := f.count(qmpQuit); n != 1 {
t.Errorf("%d quit envoyés, attendu 1 : %q", n, f.calls)
}
}
func TestShutdownQEMU_StopsWhenTheGuestShutsDownOnItsOwn(t *testing.T) {
f := &fakeQEMU{dieAfter: 1}
shutdownQEMU(f.send, "qmp.sock", 5*time.Second, time.Second, 10*time.Millisecond)
if n := f.count(qmpPowerdown); n != 1 {
t.Errorf("%d system_powerdown envoyés, attendu 1", n)
}
if n := f.count(qmpQuit); n != 0 {
t.Errorf("quit envoyé : %q", f.calls)
}
}
func TestShutdownQEMU_NothingMoreWhenQEMUIsAlreadyDead(t *testing.T) {
f := &fakeQEMU{dead: true}
shutdownQEMU(f.send, "qmp.sock", 5*time.Second, time.Second, 10*time.Millisecond)
if len(f.calls) != 1 {
t.Errorf("appels QMP : %q, attendu un seul essai", f.calls)
}
}

View file

@ -32,7 +32,7 @@ func CreateVPC(db *badger.DB, name string, cfg *configuration.Config) error {
return err
}
if err := netif.BridgeSetMaster("vp-"+vpcID+"-e", cfg.PublicBridge()); err != nil {
if err := netif.BridgeSetMaster("vp-"+vpcID+"-e", "br-public"); err != nil {
return err
}

View file

@ -25,7 +25,6 @@ type l3Probe interface {
NeighborEstablished(peer net.IP) (bool, error)
VNI(vni uint32) (frr.VNIState, error)
ExportedRoutes(table uint32, iface string) ([]*net.IPNet, error)
UnreachableDefault(table uint32) (bool, error)
LinkProblem(ns, iface string) string
}
@ -45,10 +44,6 @@ func (systemProbe) ExportedRoutes(table uint32, iface string) ([]*net.IPNet, err
return netif.TableRoutesVia(int(table), iface)
}
func (systemProbe) UnreachableDefault(table uint32) (bool, error) {
return netif.HasUnreachableDefault(int(table), l3vni.UnreachableMetric)
}
func (systemProbe) LinkProblem(ns, iface string) string {
if ns == "" {
return linkProblem(iface)
@ -150,14 +145,6 @@ func checkL3VPC(db *badger.DB, name string, r l3vni.Routing, rmac string, p l3Pr
n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d has router mac %q in frr, expected %s", r.VNI, s.RouterMAC, rmac))
}
present, err := p.UnreachableDefault(r.VNI)
switch {
case err != nil:
n.Notify(kindVPC, name, fmt.Sprintf("unreachable default of %s unreadable: %v", r.VRF, err))
case !present:
n.Notify(kindVPC, name, fmt.Sprintf("no unreachable default in %s: traffic to an unknown destination leaves through the host routing table", r.VRF))
}
actual, err := p.ExportedRoutes(r.VNI, r.VethHost)
if err != nil {
n.Notify(kindVPC, name, fmt.Sprintf("routes of %s unreadable: %v", r.VRF, err))

View file

@ -19,8 +19,6 @@ type fakeProbe struct {
routesErr error
links map[string]string
vtepErr error
unreachable map[uint32]bool
unreachErr error
}
func (f *fakeProbe) VTEPAddress(string) (net.IP, error) {
@ -51,13 +49,6 @@ func (f *fakeProbe) ExportedRoutes(table uint32, _ string) ([]*net.IPNet, error)
return out, f.routesErr
}
func (f *fakeProbe) UnreachableDefault(table uint32) (bool, error) {
if f.unreachable == nil {
return true, f.unreachErr
}
return f.unreachable[table], f.unreachErr
}
func (f *fakeProbe) LinkProblem(ns, iface string) string {
return f.links[ns+"/"+iface]
}
@ -249,32 +240,3 @@ func TestCheckL3VPCsReportsUnreadableRoutesAndVTEP(t *testing.T) {
t.Errorf("RMAC comparée sans VTEP : %q", notified(r))
}
}
func TestCheckL3VPCsReportsAVRFWithoutUnreachableDefault(t *testing.T) {
db := newTestDB(t)
seedResource(t, db, prefixVPC, "vp-s7", state.Running)
seedKV(t, db, "vpc/vp-s7/cidr", "10.241.0.0/16")
seedKV(t, db, "vpc/vp-s7/l3vni", "2700")
seedResource(t, db, prefixVPC, "vp-s8", state.Running)
seedKV(t, db, "vpc/vp-s8/cidr", "10.242.0.0/16")
seedKV(t, db, "vpc/vp-s8/l3vni", "2800")
p := seedRoutedVPC(t)
p.vni[2800] = frr.VNIState{Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:0b"}
p.unreachable = map[uint32]bool{2700: true}
r := &recorder{}
if err := CheckL3VPCs(db, bgpCfg(), p, r); err != nil {
t.Fatal(err)
}
want := []string{"vpc vp-s8: no unreachable default in vrf-s8: traffic to an unknown destination leaves through the host routing table"}
if got := notified(r); !reflect.DeepEqual(got, want) {
t.Errorf("notifications :\n%q\nattendu :\n%q", got, want)
}
p.unreachable = map[uint32]bool{2700: true, 2800: true}
p.unreachErr = errors.New("netlink refused")
r = &recorder{}
CheckL3VPCs(db, bgpCfg(), p, r)
if !r.hasProblemContaining("unreachable default of vrf-s7 unreadable: netlink refused") || r.hasProblemContaining("no unreachable default") {
t.Errorf("notifications %q", notified(r))
}
}

View file

@ -1,39 +0,0 @@
package watchdog
import (
"fmt"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/watchdog/notify"
)
const kindPublic = "public"
type publicProbe interface {
LinkProblem(name string) string
VxlanPorts(bridge string) ([]string, error)
}
type systemPublicProbe struct{}
func (systemPublicProbe) LinkProblem(name string) string { return linkProblem(name) }
func (systemPublicProbe) VxlanPorts(bridge string) ([]string, error) {
return netif.BridgeVxlanPorts(bridge)
}
func CheckPublicSegment(cfg *configuration.Config, p publicProbe, n notify.Notifier) {
bridge := cfg.PublicBridge()
if problem := p.LinkProblem(bridge); problem != "" {
n.Notify(kindPublic, bridge, problem+" (public bridge, interfaces.internet): the vpcs of this host have no public segment")
return
}
ports, err := p.VxlanPorts(bridge)
switch {
case err != nil:
n.Notify(kindPublic, bridge, fmt.Sprintf("vxlan ports unreadable: %v", err))
case len(ports) == 0:
n.Notify(kindPublic, bridge, "no vxlan port: the public segment is unreachable from this host")
}
}

View file

@ -1,77 +0,0 @@
package watchdog
import (
"errors"
"testing"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
)
type fakePublicProbe struct {
problems map[string]string
ports []string
err error
asked []string
}
func (f *fakePublicProbe) LinkProblem(name string) string {
f.asked = append(f.asked, name)
return f.problems[name]
}
func (f *fakePublicProbe) VxlanPorts(bridge string) ([]string, error) {
f.asked = append(f.asked, "ports:"+bridge)
return f.ports, f.err
}
func TestCheckPublicSegment_SilentWithAVxlanPort(t *testing.T) {
r := &recorder{}
p := &fakePublicProbe{ports: []string{"vxlan-public"}}
CheckPublicSegment(&configuration.Config{}, p, r)
if len(r.calls) != 0 {
t.Errorf("notifications = %+v, aucune attendue", r.calls)
}
if len(p.asked) != 2 || p.asked[0] != "br-public" || p.asked[1] != "ports:br-public" {
t.Errorf("sondes = %q, br-public attendu par défaut", p.asked)
}
}
func TestCheckPublicSegment_FollowsInterfacesInternet(t *testing.T) {
r := &recorder{}
p := &fakePublicProbe{ports: []string{"vxlan-public"}}
CheckPublicSegment(&configuration.Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"internet": "br-wan"}}, p, r)
if len(p.asked) != 2 || p.asked[0] != "br-wan" || p.asked[1] != "ports:br-wan" {
t.Errorf("sondes = %q, br-wan attendu", p.asked)
}
}
func TestCheckPublicSegment_ReportsAMissingBridgeWithoutReadingPorts(t *testing.T) {
r := &recorder{}
p := &fakePublicProbe{problems: map[string]string{"br-public": "interface br-public not found: Link not found"}}
CheckPublicSegment(&configuration.Config{}, p, r)
got := r.forName("br-public")
want := "interface br-public not found: Link not found (public bridge, interfaces.internet): the vpcs of this host have no public segment"
if len(got) != 1 || got[0].kind != "public" || got[0].problem != want {
t.Fatalf("notifications = %+v, une attendue : %q", r.calls, want)
}
if len(p.asked) != 1 {
t.Errorf("ports lus alors que le bridge manque : %q", p.asked)
}
}
func TestCheckPublicSegment_ReportsABridgeWithoutVxlan(t *testing.T) {
r := &recorder{}
CheckPublicSegment(&configuration.Config{}, &fakePublicProbe{}, r)
got := r.forName("br-public")
if len(got) != 1 || got[0].problem != "no vxlan port: the public segment is unreachable from this host" {
t.Errorf("notifications = %+v", r.calls)
}
}
func TestCheckPublicSegment_ReportsUnreadablePorts(t *testing.T) {
r := &recorder{}
CheckPublicSegment(&configuration.Config{}, &fakePublicProbe{err: errors.New("netlink: permission denied")}, r)
if !r.hasProblemContaining("vxlan ports unreadable: netlink: permission denied") {
t.Errorf("notifications = %+v", r.calls)
}
}

View file

@ -23,7 +23,6 @@ type Watchdog struct {
interval time.Duration
dbusDown bool
l3 l3Probe
public publicProbe
}
func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *slog.Logger, interval time.Duration) *Watchdog {
@ -42,7 +41,6 @@ func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *sl
logger: logger,
interval: interval,
l3: systemProbe{frr: frr.NewClient()},
public: systemPublicProbe{},
}
}
@ -76,7 +74,6 @@ func (w *Watchdog) tick() {
if err := CheckVMs(w.db, w.cfg, u, w.notifier); err != nil {
w.logger.Error("watchdog: vm check failed", "err", err)
}
CheckPublicSegment(w.cfg, w.public, w.notifier)
CheckBGP(w.cfg, w.l3, w.notifier)
if err := CheckL3VPCs(w.db, w.cfg, w.l3, w.notifier); err != nil {
w.logger.Error("watchdog: l3 vpc check failed", "err", err)

View file

@ -74,13 +74,6 @@ func TestNew_IntervalleValideConserve(t *testing.T) {
}
}
func TestNew_ChecksThePublicSegmentOnTheSystem(t *testing.T) {
w := New(newTestDB(t), testCfg(t), &recorder{}, nil, time.Second)
if _, ok := w.public.(systemPublicProbe); !ok {
t.Errorf("sonde du segment public = %T, systemPublicProbe attendue", w.public)
}
}
func TestNew_LoggerNil(t *testing.T) {
w := New(newTestDB(t), testCfg(t), &recorder{}, nil, time.Second)
if w.logger == nil {
@ -148,7 +141,6 @@ func TestRun_ErreurDeBaseLogueeEtBoucleContinue(t *testing.T) {
n := newChanNotifier()
l, buf := testLogger()
w := New(db, testCfg(t), n, l, 10*time.Millisecond)
w.public = &fakePublicProbe{ports: []string{"vxlan-public"}}
ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond)
defer cancel()

View file

@ -1,54 +0,0 @@
# Gabriel
## Fonctionnalités
**Délais dédiés : section `times` (#79)**
- Nouvelle section `times` de la configuration, en secondes : `timeout_vms_stop` (300),
`next_vms_shutdown` (30), `timeout_subnet_stop` (360), `timeout_vpc_stop` (420),
`timeout_subnet_start` (300), `timeout_vms_start` (300), `poll_interval` (2). Elle remplace
`dispatcher.timeout_seconds` et `dispatcher.poll_seconds`, qui servaient à des attentes de
nature différente. Une valeur nulle ou négative, ou `next_vms_shutdown` au moins égal à
`timeout_vms_stop`, fait échouer le démarrage
- **Une VM et son subnet se suppriment d'un coup** : la suppression d'un subnet est acceptée
quand ses VM sont en `deleting`, et attend leur suppression jusqu'à `timeout_subnet_stop`. Le
409 reste pour une VM ni supprimée ni en `deleting`
## Correctifs
- **Chaque VRF de VPC porte une route `unreachable default` (#81).** Une recherche qui échouait
dans la table d'une VRF continuait dans la table `main` de l'hôte : un paquet d'un locataire
vers une adresse inconnue de son VPC sortait par l'underlay, avec `169.254.0.2` pour source
(mesuré en lab). La route est posée juste après la VRF, avec la métrique maximale
`4278198272`, de sorte que toute route réelle reste prioritaire ; elle n'est pas annoncée en
EVPN et elle est retirée au démontage du VPC. Le watchdog signale une VRF qui ne l'a pas.
IPv4 seulement
- **`default_route: true` sans `gateway` est réservé au mode `bridge` (#81)** : refusé (400) en
`vxlan` et en `public_ip`. Hors `bridge`, la gateway lue dans la table de routage de l'hôte
n'est pas sur le subnet des VM : la route par défaut annoncée était inutilisable
- **La suppression d'une VM retire ses sockets QEMU (#84).** Quand QEMU échouait au démarrage
(disque absent par exemple), il pouvait laisser `<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

@ -77,8 +77,8 @@ kvm_network () {
info "réseau"
# Bridge public : sans adresse. Il reçoit le VXLAN du segment public
# (kvm_public_segment) et les veth vp-<id>-e des VPC (interfaces.internet).
# Bridge public : créé à vide, réservé pour un usage futur. Aucune adresse,
# aucun esclave, pas référencé dans la config agent.
kvm_ensure_bridge "${DRY_RUN}" "${PUBLIC_BRIDGE}"
MASTER=""
@ -153,49 +153,6 @@ EOF
info " rollback désarmé"
}
# VXLAN du segment public, partagé avec les bordures, esclave du bridge public.
# VTEP = IPv4 du bridge principal, comme les VXLAN de l'agent ; sans
# apprentissage, les MAC distantes viennent d'EVPN. Recréé si le VNI ou le VTEP
# a changé.
kvm_public_segment () {
local DRY_RUN="${1}"
local WITH_NETWORK="${2}"
local BRIDGE="${3}"
local PUBLIC_BRIDGE="${4}"
local PUBLIC_VNI="${5}"
local NAME="vxlan-public"
local VTEP CURRENT=""
[[ ${WITH_NETWORK} -eq ${FLAGS_TRUE} ]] || return 0
[[ "${PUBLIC_VNI}" =~ ^[0-9]+$ ]] && (( PUBLIC_VNI >= 1 && PUBLIC_VNI <= 16777215 )) \
|| die "VNI du segment public invalide : ${PUBLIC_VNI} (1-16777215)"
info "segment public : ${NAME}, VNI ${PUBLIC_VNI}, sur ${PUBLIC_BRIDGE}"
if [[ ${DRY_RUN} -eq ${FLAGS_TRUE} ]]
then
VTEP="<ip(${BRIDGE})>"
else
VTEP=$(ip -j addr show dev "${BRIDGE}" | jq -r '[.[0].addr_info[] | select(.family=="inet" and .scope=="global")][0].local // ""')
[[ -n "${VTEP}" ]] || die "aucune adresse IPv4 globale sur ${BRIDGE} pour le VTEP du segment public"
if ip link show dev "${NAME}" >/dev/null 2>&1
then
CURRENT=$(ip -j -d link show dev "${NAME}" | jq -r '.[0].linkinfo.info_data | "\(.id) \(.local)"')
fi
fi
if [[ -n "${CURRENT}" && "${CURRENT}" != "${PUBLIC_VNI} ${VTEP}" ]]
then
info " ${NAME} porte ${CURRENT} (VNI VTEP) : recréé"
run "${DRY_RUN}" "ip link del dev '${NAME}'"
CURRENT=""
fi
[[ -n "${CURRENT}" ]] \
|| run "${DRY_RUN}" "ip link add '${NAME}' type vxlan id ${PUBLIC_VNI} local '${VTEP}' dstport 4789 nolearning"
run "${DRY_RUN}" "ip link set dev '${NAME}' mtu 1500 master '${PUBLIC_BRIDGE}'"
run "${DRY_RUN}" "ip link set up dev '${NAME}'"
}
# Point d'entrée appelé par deploy.sh --bootstrap.
bootstrap_host () {
local DRY_RUN="${1}"
@ -205,10 +162,8 @@ bootstrap_host () {
local BRIDGE="${5}"
local PUBLIC_BRIDGE="${6}"
local ROLLBACK_DELAY="${7}"
local PUBLIC_VNI="${8:-1}"
kvm_packages "${DRY_RUN}" "${WITH_PACKAGES}"
kvm_kernel "${DRY_RUN}"
kvm_network "${DRY_RUN}" "${WITH_NETWORK}" "${UPLINK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${ROLLBACK_DELAY}"
kvm_public_segment "${DRY_RUN}" "${WITH_NETWORK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${PUBLIC_VNI}"
kvm_packages "${DRY_RUN}" "${WITH_PACKAGES}"
kvm_kernel "${DRY_RUN}"
kvm_network "${DRY_RUN}" "${WITH_NETWORK}" "${UPLINK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${ROLLBACK_DELAY}"
}

View file

@ -159,7 +159,7 @@ run_bootstrap () {
|| die "bootstrap_host() introuvable — ni ${SCRIPTS_DIR}/${NAME} ni ${BOOTSTRAP_URL} n'ont pu être chargés"
bootstrap_host "${DRY_RUN}" "${FLAGS_packages}" "${FLAGS_network}" \
"${FLAGS_uplink}" "${FLAGS_bridge}" "${FLAGS_pub_bridge}" "${FLAGS_rollback}" "${FLAGS_public_vni}"
"${FLAGS_uplink}" "${FLAGS_bridge}" "${FLAGS_pub_bridge}" "${FLAGS_rollback}"
}
resolve_tag () {
@ -335,8 +335,7 @@ main () {
DEFINE_boolean 'network' true 'Configure bridges during --bootstrap' 'n'
DEFINE_string 'uplink' 'eno1' 'Physical uplink interface' 'u'
DEFINE_string 'bridge' 'br-000000' 'Main bridge, uplink is enslaved to it' 'B'
DEFINE_string 'pub_bridge' 'br-public' 'Public bridge, carries vxlan-public' 'P'
DEFINE_integer 'public_vni' 1 'VNI of the public segment (vxlan-public)' 'N'
DEFINE_string 'pub_bridge' 'br-public' 'Reserved empty bridge' 'P'
DEFINE_integer 'rollback' 120 'Rollback reboot delay in seconds' 'R'
DEFINE_boolean 'verify' true 'Check assets against SHA256SUMS' 'V'

View file

@ -3,42 +3,33 @@
E2E_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_DIR="$(cd "${E2E_DIR}/../.." && pwd)"
BIN_DIR="${BIN_DIR:-${E2E_DIR}/topologies/bin}"
SCRIPTS_DIR="${SCRIPTS_DIR:-${E2E_DIR}/topologies/scripts}"
BINARIES="agent dhcp metadata"
SCRIPTS="bootstrap_kvm.sh"
usage () {
cat >&2 <<USAGE
usage: ${0##*/} [--clean]
sans option : compile ${BINARIES} pour linux/amd64 depuis l'arbre courant dans ${BIN_DIR},
copie ${SCRIPTS} dans ${SCRIPTS_DIR} ; le prochain lab les installe par-dessus
la release épinglée dans topologies/provision/hypervisor.sh
--clean : vide ${BIN_DIR} et ${SCRIPTS_DIR} ; le prochain lab teste la release seule
sans option : compile ${BINARIES} pour linux/amd64 depuis l'arbre courant dans ${BIN_DIR} ;
le prochain lab les installe par-dessus la release épinglée dans
topologies/provision/hypervisor.sh
--clean : vide ${BIN_DIR} ; le prochain lab teste la release seule
USAGE
exit 2
}
clean () {
local binary script
local binary
for binary in ${BINARIES}; do
rm -f "${BIN_DIR}/${binary}" || return 1
done
for script in ${SCRIPTS}; do
rm -f "${SCRIPTS_DIR}/${script}" || return 1
done
}
build () {
local binary script
local binary
for binary in ${BINARIES}; do
echo "== ${binary}" >&2
(cd "${REPO_DIR}" && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o "${BIN_DIR}/${binary}" "./cmd/${binary}") || return 1
done
for script in ${SCRIPTS}; do
echo "== ${script}" >&2
cp "${REPO_DIR}/scripts/${script}" "${SCRIPTS_DIR}/${script}" || return 1
done
(cd "${BIN_DIR}" && sha256sum ${BINARIES} 2>/dev/null || shasum -a 256 ${BINARIES})
}

View file

@ -56,7 +56,7 @@ api_state () {
wait_state () {
local path="${1}" want="${2}" i s code=""
for i in $(seq 1 240); do
for i in $(seq 1 180); do
s=$(api_state "${path}")
[ "${s}" = "${want}" ] && return 0
if [ "${want}" = deleted ] && [ -z "${s}" ]; then

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, #81
# tickets: #41, #57, #33, #62, #74
on hv1 <<'NODE'
check "VPC vp-t11a, l3vni 1100 (témoin)" vpc_create vp-t11a 10.11.0.0/16 1100
@ -19,8 +19,6 @@ check "sn-t11a : adresse d'émission calculée .253" test "$(api_field subnets/s
check "subnet : nom déjà pris, 409" expect_code 409 api_post_code subnets '{"name":"sn-t11a","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1101,"cidr":"10.11.1.0/24"}'
check "subnet : mode inconnu, 422" expect_code 422 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vlan","vxlan_id":1109,"cidr":"10.11.9.0/24"}'
check "subnet : interface_ip fournie en vxlan, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/24","interface_ip":"10.11.9.1"}'
check "subnet : default_route sans gateway en vxlan, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/24","default_route":true}'
check "subnet : default_route sans gateway, mode omis, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","vxlan_id":1109,"cidr":"10.11.9.0/24","default_route":true}'
check "subnet : interface_ip absente en bridge, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"bridge","cidr":"10.11.9.0/24"}'
check "subnet : préfixe /30 en vxlan, 422" expect_code 422 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/30"}'
check "subnet : préfixe /29 en vxlan accepté (témoin)" expect_code 202 api_post_code subnets '{"name":"sn-t11p","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1103,"cidr":"10.11.3.0/29"}'

View file

@ -1,6 +1,6 @@
# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom
# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom
# hôtes: hv1
# tickets: #41, #84, #79
# tickets: #41
on hv1 <<'NODE'
check "VPC vp-t12a" vpc_create vp-t12a 10.12.0.0/16
@ -23,11 +23,8 @@ check "suppression d'un VPC inconnu, 404" expect_code 404 api_code DELETE vpcs/v
check "VM t12-err sur un disque absent : acceptée, 202 (pas de refus synchrone)" expect_code 202 api_post_code vms "$(vm_body t12-err sn-t12a 10.12.1.11 "${VOLUMES}/t12-absent.qcow2")"
check "t12-err passe en error" wait_state vms/t12-err error
info "t12-err : sockets laissés par QEMU : $(ls /run/two/vms/serial/t12-err.sock /run/two/vms/monitor/t12-err.sock /run/two/vms/qmp/t12-err.sock 2>&1 | tr '\n' ' ')"
check "t12-err : les trois sockets QEMU posés à la main s'ils manquent" sh -c 'for d in serial monitor qmp; do [ -e "/run/two/vms/${d}/t12-err.sock" ] || : > "/run/two/vms/${d}/t12-err.sock" || exit 1; done'
check "suppression de t12-err depuis error, 202" expect_code 202 api_code DELETE vms/t12-err
check "t12-err supprimée" wait_state vms/t12-err deleted
check "t12-err : aucun socket QEMU laissé dans /run/two/vms" sh -c 'for d in serial monitor qmp; do [ ! -e "/run/two/vms/${d}/t12-err.sock" ] || { echo "/run/two/vms/${d}/t12-err.sock laissé"; exit 1; }; done'
check "t12-err : aucune unité two-vm-t12-err" sh -c '! systemctl list-units --all --plain --no-legend "two-vm-t12-err*" | grep -q .'
check "suppression de t12-a" vm_delete t12-a
@ -41,16 +38,4 @@ check "sn-t12a recréé puis supprimé" wait_state subnets/sn-t12a deleted
check "suppression de vp-t12a, sans subnet, 202 (témoin)" expect_code 202 api_code DELETE vpcs/vp-t12a
check "vp-t12a supprimé" wait_state vpcs/vp-t12a deleted
check "vp-t12a recréé sous le même nom" vpc_create vp-t12a 10.12.0.0/16
check "subnet sn-t12q (VNI 1202)" subnet_create sn-t12q vp-t12a 1202 10.12.2.0/24
check "VM t12-q" vm_create t12-q sn-t12q 10.12.2.10
sleep 3
T12Q=$(date +%s)
check "t12-q : suppression 3 s après running, 202" expect_code 202 api_code DELETE vms/t12-q
check "sn-t12q : suppression envoyée aussitôt, acceptée malgré t12-q en deleting, 202" expect_code 202 api_code DELETE subnets/sn-t12q
info "sn-t12q juste après sa suppression : $(api_state subnets/sn-t12q), t12-q : $(api_state vms/t12-q)"
check "t12-q supprimée" wait_state vms/t12-q deleted
check "sn-t12q supprimé après t12-q" wait_state subnets/sn-t12q deleted
info "t12-q puis sn-t12q supprimés en $(( $(date +%s) - T12Q )) s"
check "t12-q : arrêtée bien avant times.timeout_vms_stop (300 s), par un system_powerdown renvoyé si le premier est perdu" test "$(( $(date +%s) - T12Q ))" -lt 200
NODE

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, unreachable default dans la VRF, démontage d'un VPC routé
# fonctionnalité: routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, démontage d'un VPC routé
# hôtes: hv1 hv2
# tickets: #41, #81
# tickets: #41
on hv1 <<'NODE'
KEY=$(vm_key)
@ -23,9 +23,6 @@ check "hv1 : vrf-t51 contient exactement brl3-t51 et l3-t51-o" sh -c "[ \"\$1\"
check "hv1 : brl3-t51 sans adresse IPv4" sh -c "! ip -4 -o addr show dev brl3-t51 | grep -q inet"
check "hv1 : RMAC de brl3-t51 dérivée du VTEP 192.168.14.11" sh -c "ip -o link show brl3-t51 | grep -q 'link/ether 02:02:c0:a8:0e:0b '"
check "hv1 : route du supernet dans vp-t51 vers le transit" sh -c "ip -n vp-t51 -4 route show 10.51.0.0/18 | grep -q 'via 169.254.0.1 dev l3-t51-i'"
check "hv1 : table 5100 de vrf-t51 : unreachable default de métrique 4278198272" sh -c "ip -4 route show table 5100 | grep -q '^unreachable default metric 4278198272'"
check "hv1 : adresse du VPC inconnue (10.51.5.5) injoignable dans vrf-t51, pas de repli sur la table main" sh -c "ip -4 route get 10.51.5.5 vrf vrf-t51 2>&1 | grep -q 'No route to host'"
check "hv1 : adresse externe (8.8.8.8) injoignable dans vrf-t51" sh -c "ip -4 route get 8.8.8.8 vrf vrf-t51 2>&1 | grep -q 'No route to host'"
check "hv1 : forwarding sur brl3-t51 et l3-t51-o" sh -c "[ \"\$(sysctl -n net.ipv4.conf.brl3-t51.forwarding net.ipv4.conf.l3-t51-o.forwarding | tr '\n' ' ')\" = '1 1 ' ]"
check "hv1 : ip_forward dans le netns vp-t51" sh -c "[ \"\$(ip netns exec vp-t51 sysctl -n net.ipv4.ip_forward)\" = 1 ]"
info "hv1 : ip_forward global de l'hôte : $(sysctl -n net.ipv4.ip_forward) (non modifié par l'agent)"
@ -44,7 +41,6 @@ check "hv2 : RMAC de hv1 dans la FDB de vxl3-t51" sh -c "bridge fdb show dev vxl
NODE
on rr1 <<'NODE'
check "rr1 : RT-5 10.51.1.10/32 de hv1 (RD 192.168.14.11:5100) reçue et réfléchie" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.11:5100 type prefix' | grep -q '\[10.51.1.10\]'"
check "rr1 : aucune RT-5 0.0.0.0/0 de hv1 (RD 192.168.14.11:5100) : l'unreachable default n'est pas annoncée" sh -c "! vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.11:5100 type prefix' | grep -q '\[0.0.0.0\]'"
check "rr1 : RT-5 10.51.2.20/32 de vp-t51b (RD 192.168.14.12:5101) présente (témoin du test négatif)" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.12:5101 type prefix' | grep -q '\[10.51.2.20\]'"
NODE
on hv1 <<'NODE'
@ -60,7 +56,6 @@ check "TTL 2 : expire dans la VRF de hv1 (169.254.0.1)" vm_grep vp-t51 10.51.1.1
check "TTL 5 : atteint t51-b — quatre routeurs : gateway hv1, VRF hv1, VRF hv2, netns hv2" vm_ssh vp-t51 10.51.1.10 'ping -n -c 1 -W 2 -t 5 10.51.2.10'
check "hv1 : vrf-t51 n'importe pas 10.51.2.20/32 de vp-t51b (RT 64600:5101)" sh -c "[ -z \"\$(ip -4 route show vrf vrf-t51 10.51.2.20)\" ]"
check "t51-a ne joint pas t51-x, autre VPC, même plage" vm_fails vp-t51 10.51.1.10 'ping -c 3 -W 2 10.51.2.20'
check "t51-a vers une adresse inconnue du VPC (10.51.5.5) : refusé par vrf-t51 (169.254.0.1), rien vers l'underlay" vm_grep vp-t51 10.51.1.10 'ping -n -c 2 -W 2 10.51.5.5' 'From 169.254.0.1 .*Unreachable'
NODE
on hv2 <<'NODE'
BGPD=$(pidof bgpd)
@ -69,11 +64,9 @@ check "hv2 : suppression de t51-x" vm_delete t51-x
check "hv2 : vrf-t51b ne porte plus le /32 de t51-x" test -z "$(ip -4 route show vrf vrf-t51b 10.51.2.20/32)"
check "hv2 : suppression de sn-t51x" api_delete subnets/sn-t51x
check "hv2 : sn-t51x supprimé" wait_state subnets/sn-t51x deleted
check "hv2 : table 5101 de vrf-t51b : unreachable default avant le démontage (témoin)" sh -c "ip -4 route show table 5101 | grep -q '^unreachable default metric 4278198272'"
check "hv2 : suppression de vp-t51b" api_delete vpcs/vp-t51b
check "hv2 : vp-t51b supprimé" wait_state vpcs/vp-t51b deleted
check "hv2 : plus aucune interface de vp-t51b" sh -c "! ip -o link show | grep -qE '(vrf|brl3|vxl3)-t51b|l3-t51b-o'"
check "hv2 : table 5101 vide après le démontage, unreachable default comprise" sh -c "! ip -4 route show table 5101 2>&1 | grep -qE '^(unreachable|default|[0-9])'"
check "hv2 : plus rien de vrf-t51b dans FRR, en mémoire ni dans frr.conf" sh -c "! vtysh -c 'show running-config' | grep -q 'vrf-t51b' && ! grep -q 'vrf-t51b' /etc/frr/frr.conf"
check "hv2 : bgpd n'a pas redémarré pendant le démontage" sh -c "[ \"\$(pidof bgpd)\" = '${BGPD}' ]"
check "hv2 : vp-t51 toujours en service" wait_l3vni 5100 02:02:c0:a8:0e:0c

View file

@ -1,6 +1,6 @@
# fonctionnalité: watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, unreachable default absente signalée, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais
# fonctionnalité: watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais
# hôtes: hv1 hv3
# tickets: #41, #81
# tickets: #41
on hv1 <<'NODE'
check "hv1 : VPC vp-t53, l3vni 5300" vpc_create vp-t53 10.53.0.0/16 5300
@ -28,10 +28,6 @@ check "watchdog : /32 de t53-m retiré à la main" ip route del 10.53.1.50/32 vr
check "hypothèse du test : FRR retire le /32 de t53-m de sa table BGP quand la route du noyau disparaît" wait_bgp_paths vp-t53 10.53.1.50/32 0
check "watchdog : /32 manquant signalé" wait_watchdog "route 10.53.1.50/32 not exported in vrf-t53"
check "watchdog : /32 de t53-m rétabli" ip route replace 10.53.1.50/32 via 169.254.0.2 dev l3-t53-o vrf vrf-t53
check "watchdog : aucune alerte sur l'unreachable default avant son retrait (témoin)" watchdog_quiet_about 60 "no unreachable default"
check "watchdog : unreachable default retirée à la main de la table 5300" ip route del unreachable default metric 4278198272 table 5300
check "watchdog : unreachable default absente signalée" wait_watchdog "no unreachable default in vrf-t53"
check "watchdog : unreachable default rétablie" ip route replace unreachable default metric 4278198272 table 5300
check "watchdog : aucune alerte BGP ni L3VNI sur hv1" watchdog_l3_quiet 60
NODE
on hv3 <<'NODE'

View file

@ -35,11 +35,11 @@ nodes:
{ role: host, image: debian12, cpus: 4, memory: 16384,
segments: [underlay, lan], addresses: { underlay: 192.168.14.11, lan: 10.33.0.11 },
frr: frr/hv1.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin, scripts: scripts },
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin },
services: [agent.service] }
hv2:
{ role: host, image: debian12, cpus: 4, memory: 16384,
segments: [underlay, lan], addresses: { underlay: 192.168.14.12, lan: 10.33.0.12 },
frr: frr/hv2.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin, scripts: scripts },
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin },
services: [agent.service] }

View file

@ -35,18 +35,18 @@ nodes:
{ role: host, image: debian12, cpus: 4, memory: 16384,
segments: [underlay, lan], addresses: { underlay: 192.168.14.11, lan: 10.33.0.11 },
frr: frr/hv1.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin, scripts: scripts },
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin },
services: [agent.service] }
hv2:
{ role: host, image: debian12, cpus: 4, memory: 16384,
segments: [underlay, lan], addresses: { underlay: 192.168.14.12, lan: 10.33.0.12 },
frr: frr/hv2.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin, scripts: scripts },
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin },
services: [agent.service] }
hv3:
{ role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.13 }, frr: frr/hv3.conf, provision: provision/hypervisor.sh,
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin, scripts: scripts },
post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin },
services: [agent.service] }
bd1:
{ role: host, image: debian12, cpus: 1, memory: 1024, segments: [underlay],

View file

@ -1,16 +1,16 @@
#!/bin/sh
set -eu
VNI=1
VNI=66001
GATEWAY=240.0.0.1/24
GATEWAY_MAC=02:01:00:00:00:01
GATEWAY_MAC=02:01:00:01:01:d1
DESTINATION=240.255.0.1/32
VTEP=$(ip -4 -o addr show dev "${LAB_UPLINK}" scope global | awk 'NR == 1 {sub("/.*", "", $4); print $4}')
[ -n "${VTEP}" ] || { echo "border: no IPv4 on ${LAB_UPLINK}" >&2; exit 1; }
ip link add br-public type bridge
ip link set br-public address "${GATEWAY_MAC}"
ip link add vxlan-public type vxlan id "${VNI}" local "${VTEP}" dstport 4789 nolearning
ip link set vxlan-public mtu 1500 master br-public
ip link set vxlan-public up
ip link add "vxlan-${VNI}" type vxlan id "${VNI}" local "${VTEP}" dstport 4789 nolearning
ip link set "vxlan-${VNI}" mtu 1500 master br-public
ip link set "vxlan-${VNI}" up
ip link set br-public up
ip addr add "${GATEWAY}" dev br-public
ip link add internet type dummy

View file

@ -1,7 +1,6 @@
#!/bin/sh
set -eu
RELEASE=0.2.0
PUBLIC_VNI=1
GIT_SERVER=https://git.g3e.fr/
REPO=syonad/two
n=0
@ -29,11 +28,6 @@ for script in deploy.sh bootstrap_kvm.sh; do
done
chmod 0755 deploy.sh bootstrap_kvm.sh
bash ./deploy.sh --noup_script -i -u "${LAB_UPLINK}" -t "${RELEASE}"
if [ -f "${LAB_FILES}/scripts/bootstrap_kvm.sh" ]; then
bash -c 'FLAGS_TRUE=0; FLAGS_FALSE=1; . ./deploy.sh && . "$1" && kvm_public_segment "${FLAGS_FALSE}" "${FLAGS_TRUE}" br-000000 br-public "$2"' \
lab "${LAB_FILES}/scripts/bootstrap_kvm.sh" "${PUBLIC_VNI}"
echo "lab: segment public posé par le bootstrap_kvm.sh de l'arbre courant (VNI ${PUBLIC_VNI})"
fi
for binary in "${LAB_FILES}"/bin/*; do
[ -f "${binary}" ] || continue
name=$(basename "${binary}")