Merge branch 'feature-41'
All checks were successful
Documentation / publish (push) Successful in 1m23s

This commit is contained in:
GnomeZworc 2026-10-12 15:07:10 +02:00
commit 4438bb3916
Signed by: nicolas.boufideline
GPG key ID: 4406BBBF8845D632
82 changed files with 4267 additions and 142 deletions

View file

@ -45,13 +45,13 @@ paths:
schema:
$ref: "#/components/schemas/VPC"
"400":
description: Missing required field or invalid request body
description: Missing required field, invalid request body, or l3vni out of range
content:
application/json:
schema:
$ref: "#/components/schemas/Error"
"409":
description: VPC already exists
description: VPC already exists, l3vni already used by another VPC, or l3vni requested on an agent without a bgp section
content:
application/json:
schema:
@ -281,7 +281,7 @@ paths:
"404":
$ref: "#/components/responses/NotFound"
"409":
description: Subnet not deletable — only running or error states can be deleted
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:
@ -317,6 +317,17 @@ components:
type: string
description: CIDR block for the entire VPC address space
example: "10.0.0.0/16"
l3vni:
type: integer
format: int32
minimum: 1
maximum: 65535
description: >-
Optional. L3VNI of the VPC, used for inter-subnet routing between hypervisors
(symmetric IRB). Also the id of the routing table of the VPC VRF, so 253-255 are
rejected, and the number of the route distinguisher <vtep>:<l3vni>, which holds 16 bits. Requires the bgp section in the agent configuration, and must not be used
by another VPC of the agent. Absent: the VPC has no L3VNI.
example: 4001
VPC:
type: object
@ -331,6 +342,10 @@ components:
cidr:
type: string
example: "10.0.0.0/16"
l3vni:
type: integer
description: L3VNI of the VPC, absent when the VPC has none
example: 4001
SubnetCreateRequest:
type: object

View file

@ -13,7 +13,9 @@ import (
agentapi "git.g3e.fr/syonad/two/internal/api/agent"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
dispatcher "git.g3e.fr/syonad/two/internal/dispatcher/agent"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/internal/migration"
"git.g3e.fr/syonad/two/internal/netif"
agentmetrics "git.g3e.fr/syonad/two/internal/prometheus/agent"
"git.g3e.fr/syonad/two/internal/watchdog"
"git.g3e.fr/syonad/two/internal/watchdog/notify"
@ -29,11 +31,14 @@ const shutdownTimeout = 20 * time.Second
func main() {
confFile := flag.String("config", "/etc/two/agent.yml", "config file path")
flag.Parse()
os.Exit(run(*confFile))
}
cfg, err := configuration.LoadConfig(*confFile)
func run(confFile string) int {
cfg, err := configuration.LoadConfig(confFile)
if err != nil {
slog.Error("failed to load config", "error", err)
return
return 1
}
log := logger.New(cfg.Logger.Level, cfg.Logger.Debug)
@ -50,12 +55,20 @@ func main() {
// d'états, et des ressources transitoires orphelines d'un arrêt précédent.
if err := migration.MigrateStates(db, log.With(slog.String("component", "migration"))); err != nil {
log.Error("failed to migrate states", "error", err)
return
return 1
}
if err := migration.MigrateVMNICs(db, log.With(slog.String("component", "migration"))); err != nil {
log.Error("vm nic migration failed", "error", err)
return
return 1
}
if cfg.BGP.Enabled() {
if err := applyBGPBase(cfg, frr.NewClient()); err != nil {
log.Error("failed to apply the bgp base configuration", "error", err)
return 1
}
log.Info("bgp base configuration applied", "asn", cfg.BGP.ASN, "route_reflectors", cfg.BGP.RouteReflectors)
}
q := worker.New(cfg.Worker.BufferSize)
@ -108,6 +121,23 @@ func main() {
servers["admin"] = adminSrv
}
closeDB = shutdown(log, q, servers, shutdownTimeout)
return 0
}
type baseApplier interface {
ApplyBase(frr.Base) error
}
func applyBGPBase(cfg *configuration.Config, frrClient baseApplier) error {
reflectors, err := cfg.BGP.Reflectors()
if err != nil {
return err
}
vtep, err := netif.VTEPAddress(cfg.DefaultInterface)
if err != nil {
return err
}
return frrClient.ApplyBase(frr.Base{ASN: cfg.BGP.ASN, RouterID: vtep, RouteReflectors: reflectors})
}
type httpShutdowner interface {

View file

@ -5,11 +5,15 @@ import (
"errors"
"io"
"log/slog"
"os"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/pkg/worker"
)
@ -96,3 +100,46 @@ func TestShutdown_SansServeur(t *testing.T) {
t.Fatal("l'absence de serveur ne doit pas empêcher un arrêt propre")
}
}
type fakeBase struct{ called bool }
func (f *fakeBase) ApplyBase(frr.Base) error {
f.called = true
return nil
}
func TestApplyBGPBase_RefusesAnInvalidSectionBeforeTouchingFRR(t *testing.T) {
cfg := &configuration.Config{}
cfg.BGP.RouteReflectors = []string{"10.255.255.1"}
f := &fakeBase{}
if err := applyBGPBase(cfg, f); err == nil || !strings.Contains(err.Error(), "bgp.asn must be set") {
t.Errorf("erreur %v", err)
}
if f.called {
t.Error("ApplyBase appelé avec une section bgp invalide")
}
}
func TestRunExitsNonZeroWhenTheConfigCannotBeLoaded(t *testing.T) {
conf := filepath.Join(t.TempDir(), "agent.yml")
if err := os.WriteFile(conf, []byte("bgp: [non: valide\n"), 0o600); err != nil {
t.Fatal(err)
}
if code := run(conf); code != 1 {
t.Errorf("code de sortie %d, 1 attendu", code)
}
}
func TestRunExitsNonZeroWhenTheBGPBaseCannotBeApplied(t *testing.T) {
dir := t.TempDir()
conf := filepath.Join(dir, "agent.yml")
yml := "database:\n path: " + filepath.Join(dir, "db") + "\n" +
"default_interface: two-test-absent0\n" +
"bgp:\n asn: 64600\n route_reflectors: [10.255.255.1]\n"
if err := os.WriteFile(conf, []byte(yml), 0o600); err != nil {
t.Fatal(err)
}
if code := run(conf); code != 1 {
t.Errorf("code de sortie %d, 1 attendu", code)
}
}

View file

@ -312,18 +312,20 @@ func TestRun_RenderShipsTheExampleFRRConfigs(t *testing.T) {
if code != 0 {
t.Fatalf("code %d, stderr %s", code, stderr)
}
for node, want := range map[string]string{
"sw1": "router bgp 65100",
"rr1": "bgp listen range 192.168.14.0/24 peer-group fabric",
"hv1": "bgp router-id 192.168.14.11",
"hv2": "bgp router-id 192.168.14.12",
for node, wants := range map[string][]string{
"sw1": {"router bgp 65100"},
"rr1": {"bgp listen range 192.168.14.0/24 peer-group fabric"},
"hv1": {"hostname hv1", "route_reflectors: [10.255.255.1]"},
"hv2": {"hostname hv2", "route_reflectors: [10.255.255.1]"},
} {
data, err := os.ReadFile(filepath.Join(out, node, "user-data"))
if err != nil {
t.Fatal(err)
}
if !strings.Contains(string(data), want) {
t.Errorf("%s user-data does not carry %q", node, want)
for _, want := range wants {
if !strings.Contains(string(data), want) {
t.Errorf("%s user-data does not carry %q", node, want)
}
}
}
}

View file

@ -35,6 +35,15 @@ interfaces:
internet: br-000000
admin: br-000000
# BGP control plane of the hypervisor (optional).
# Absent: the agent leaves FRR alone. Present: at every start, before serving its
# API, the agent applies the base BGP configuration through vtysh (router-id = the
# primary IPv4 of default_interface) and saves it with "write memory".
# Changing the asn requires removing the previous instance by hand.
# bgp:
# asn: 64600
# route_reflectors: [10.255.255.1]
# Metadata server runtime directory (cloud-init files per VM)
metadata:
run_dir: "/run/two/metadata"

View file

@ -8,6 +8,7 @@ de sérialisation structurée.
vpc/<name>/state → creating | running | error | deleting | deleted
vpc/<name>/cidr → <cidr>
vpc/<name>/l3vni → <id> (optionnel : VPC routé par L3VNI)
subnet/<name>/state → creating | running | error | deleting | deleted
subnet/<name>/vpc → <vpc-name>
@ -21,9 +22,10 @@ de sérialisation structurée.
subnet/<name>/dhcp/<ip> → <mac>
vm/<name>/state → creating | running | error | deleting | deleted
vm/<name>/subnet → <subnet-name>
vm/<name>/tap_id → <int>
vm/<name>/ip → <ip>
vm/<name>/nic/<i>/subnet → <subnet-name> (une interface par index, ordre du tableau interfaces)
vm/<name>/nic/<i>/ip → <ip>
vm/<name>/nic/<i>/primary → "true" (exactement une interface ; absent sur les autres)
vm/<name>/nic/<i>/tap_id → <int> (alloué au premier démarrage, puis conservé)
vm/<name>/metadata_port → <port>
vm/<name>/disk/<dev> → <path> (une clé par disque : sda, vda, …)
vm/<name>/memory → <int> (Mo)
@ -36,9 +38,14 @@ de sérialisation structurée.
Règles
------
**Pas de duplication.** Une ressource ne stocke que ce qui lui est propre. Une VM garde le lien
``vm/<name>/subnet`` ; le VPC, le bridge et l'``interface_ip`` sont lus depuis le subnet, leur
source canonique.
**Pas de duplication.** Une ressource ne stocke que ce qui lui est propre. Une interface de VM
garde le lien ``vm/<name>/nic/<i>/subnet`` ; le VPC, le mode, le bridge et l'``interface_ip`` sont
lus depuis le subnet, leur source canonique. De même, la L3VNI d'un VPC n'est stockée que sous
``vpc/<name>/l3vni`` : RT, RD, MAC de routeur et table de routage en sont calculés.
**Ancien schéma des VM.** Avant le multi-interfaces, une VM portait directement ``subnet``, ``ip``
et ``tap_id``. L'agent les migre au démarrage vers ``nic/0/…``, marquée ``primary``, avant
d'ouvrir son API ; une VM qui a déjà des clés ``nic/`` est laissée telle quelle.
**Les états passent par ``state``.** Toujours ``state.Set`` / ``state.Get`` : ``Set`` refuse une
valeur hors énumération, ``Get`` refuse de retourner une valeur non reconnue. ``error`` n'est

View file

@ -39,6 +39,13 @@ Paquets
- migrations idempotentes jouées au démarrage de l'agent
* - ``internal/vpc``, ``internal/subnet``
- création et suppression bas niveau (netns + netif)
* - ``internal/l3vni``
- routage d'une VPC par L3VNI : VRF, L3VNI, transit, configuration FRR, export des routes
``/24`` et ``/32``
* - ``internal/frr``
- génération des commandes FRR, seul point d'appel à ``vtysh``
* - ``internal/sysctl``
- écriture sous ``/proc/sys``, dans un netns si besoin
* - ``internal/netns``
- network namespaces : create/enter/delete/call
* - ``internal/netif``

View file

@ -42,6 +42,17 @@ vxlan
Le subnet vit dans le netns du VPC. La VM n'est donc **pas joignable depuis l'host** sans route
explicite — point à connaître avant de câbler un outil externe dessus.
Le bridge du subnet, qui porte ``interface_ip``, a une **MAC de gateway propre à l'hôte**, calculée
depuis son VTEP — l'IPv4 primaire du ``local_iface`` : ``02:03`` suivi des quatre octets de
l'adresse (VTEP ``192.168.14.12`` → ``02:03:c0:a8:0e:0c``). Unique dans le fabric, elle est la
même pour tous les subnets d'un hôte, chacun étant un domaine L2 distinct. Elle n'est posée qu'à la
création du subnet — un subnet créé avant garde la MAC choisie par le noyau jusqu'à sa recréation.
Une MAC de gateway **identique sur tous les hôtes** (anycast) a été essayée puis retirée : apprise
sur le veth du subnet, elle était annoncée en EVPN par chaque hôte et détectée en double ; et une
gateway ne pouvait plus joindre en L2 une VM d'un autre hôte, la réponse revenant à la gateway
locale de la VM. Le cache ARP d'une VM migrée à chaud est un sujet de la migration, pas du subnet.
bridge
------

View file

@ -20,6 +20,40 @@ d'isolation : deux VPC ne se voient pas, et peuvent réutiliser les mêmes plage
Un VPC ne peut être supprimé que si tous ses subnets le sont déjà — sinon 409.
Routage entre hyperviseurs : ``l3vni``
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Un VPC créé avec ``l3vni`` route ses subnets entre hyperviseurs par un **VNI de transit** propre
au VPC (IRB symétrique, `#41 <https://git.g3e.fr/syonad/two/issues/41>`_) : un hyperviseur n'a
plus besoin de porter un subnet pour joindre ses VM. Sans ``l3vni``, le VPC se comporte comme
avant. Le champ exige la section ``bgp`` de l'agent (:doc:`/exploitation/configuration`) et ne
se change pas après création.
**Plan de VNI.** L3VNI et ``vxlan_id`` des subnets partagent l'espace des VNI VXLAN : la plage
**1–65535** (sauf 253–255, tables du noyau) est réservée aux L3VNI des VPC, **65536–16777215** aux
subnets. L'agent n'impose que la première borne (le RD ``<VTEP>:<l3vni>`` porte un numéro sur
16 bits) ; le respect du plan revient à l'appelant, qui alloue les deux.
À la création, l'agent pose sur l'hyperviseur, pour un VPC ``vp-<id>`` :
.. code-block:: text
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
Dans le netns, le ``cidr`` du VPC est routé vers ``169.254.0.1`` ; le transit ``/30`` est le même
sur tous les hyperviseurs et pour tous les VPC. L'agent active le forwarding IPv4 dans le netns,
et sur l'hôte sur ``brl3-<id>`` et ``l3-<id>-o``, les deux interfaces d'entrée de la VRF ; il ne
touche pas au réglage global, que ``bootstrap_kvm.sh`` met déjà à 1. FRR reçoit la VRF, son ``vni``, une instance
``router bgp <asn> vrf vrf-<id>`` avec RD ``<VTEP>:<l3vni>`` et RT ``<asn>:<l3vni>``, et
l'export des routes du ``cidr`` présentes dans la VRF.
La suppression retire d'abord la configuration de routage de FRR, puis les interfaces, puis la
VRF de FRR. Cet ordre est imposé : supprimer la VRF du noyau sous une instance BGP encore
configurée fait planter ``bgpd`` (FRR 10.7.1).
Subnet
------
@ -34,6 +68,11 @@ hosts dont le nommage réseau diffère.
Le comportement réseau dépend du :doc:`mode </concepts/modes-reseau>`.
Un subnet ne peut être supprimé que si aucune VM non supprimée n'a d'interface dessus — sinon
409, avec la liste des VM. Dans un VPC routé par ``l3vni``, un subnet ``vxlan`` annonce son
préfixe dans la VRF du VPC à la création et le retire en premier à la suppression : c'est le
filet qui couvre une VM tant que son ``/32`` n'est pas annoncé.
VM
--
@ -44,6 +83,12 @@ le nom de l'interface dans le guest. Exactement une interface doit être ``prima
la route par défaut et le serveur de metadata. Tous les subnets d'une VM doivent appartenir au
**même VPC**.
**Routes.** Dans un VPC routé par ``l3vni``, chaque interface sur un subnet ``vxlan`` est annoncée
en ``/32`` dans la VRF du VPC une fois QEMU démarré, juste avant le passage en ``running``. À la
suppression, ces ``/32`` sont retirés **avant** l'arrêt de QEMU. Comme un subnet ne peut être
supprimé tant qu'une VM l'utilise, le ``/32`` d'une VM est toujours retiré avant le ``/24`` de son
subnet — l'ordre qui évite le trou noir de `#41 <https://git.g3e.fr/syonad/two/issues/41>`_.
**Stockage.** Un seul disque ``vdX`` (virtio-blk) par VM ; les disques supplémentaires passent
par le contrôleur SCSI (``sdX``). Cette contrainte vient de la carte PCI figée — voir
:doc:`/architecture/contraintes`.

View file

@ -27,11 +27,41 @@ l'agent désactive l'apprentissage et ne configure aucun voisin — cf.
Configuration de FRR
~~~~~~~~~~~~~~~~~~~~
Seul ``bgpd`` est activé dans ``/etc/frr/daemons``. D'un hyperviseur à l'autre ne changent que
``hostname`` et ``router-id``, l'adresse de l'hyperviseur sur son segment.
Seul ``bgpd`` est activé dans ``/etc/frr/daemons``. Le reste est posé par l'agent, à chaque
démarrage, à partir de la section ``bgp`` de ``agent.yml`` (:doc:`/exploitation/configuration`) :
.. literalinclude:: ../../test/e2e/topologies/frr/hv1.conf
:language: text
.. code-block:: yaml
bgp:
asn: 64600
route_reflectors: [10.255.255.1]
L'agent en déduit la configuration ci-dessous ; le ``router-id`` est l'adresse IPv4 primaire de
``default_interface``, la seule valeur qui change d'un hyperviseur à l'autre. ``hostname`` et
``log`` ne sont pas gérés par l'agent : ce sont les seules lignes à déposer dans ``frr.conf``.
.. code-block:: text
router bgp 64600
bgp router-id 192.168.14.11
no bgp default ipv4-unicast
neighbor fabric peer-group
neighbor fabric remote-as 64600
neighbor fabric capability extended-nexthop
neighbor 10.255.255.1 peer-group fabric
!
address-family l2vpn evpn
neighbor fabric activate
advertise-all-vni
exit-address-family
exit
.. warning::
Avec une section ``bgp``, l'agent **refuse de démarrer** si ``vtysh`` ne répond pas, et
``agent.service`` ne le relance pas. L'ordre au démarrage est donc : migration réseau vers
``br-000000``, **puis** FRR, **puis** l'agent. FRR démarré avant la migration peut perdre la
route par défaut quand elle change d'interface, et ne plus joindre le route reflector.
Ce qu'elle établit :

View file

@ -112,15 +112,16 @@ Commandes
et le prix ; ne crée rien
up crée le serveur de lab, attend la fin de son installation et son SSH,
puis le prépare (voir prepare)
status liste les serveurs de lab du projet
status liste les serveurs de lab du projet, dans toutes les zones candidates
ssh [commande] se connecte au serveur de lab ; avec une commande, un terminal n'est demandé
que si l'entrée standard en est un
prepare installe sur le serveur ce dont lab a besoin (qemu, genisoimage), vérifie
/dev/kvm et la virtualisation imbriquée ; lancé aussi par up
/dev/kvm, la virtualisation imbriquée et un CPU x86-64-v3 ; lancé aussi par up
push <topologie> compile cmd/lab pour linux/amd64 et dépose sur le serveur ~/lab et le
répertoire de la topologie dans ~/topology/ (avec les fichiers qu'elle
référence) ; ensuite : ssh './lab up topology/<topologie>'
down supprime tous les serveurs de lab du projet et attend leur disparition
down supprime tous les serveurs de lab du projet, dans toutes les zones candidates,
et attend leur disparition
session [cmd] up, puis la commande distante (ou un shell), puis down quoi qu'il arrive
``plan`` et ``status`` sont **gratuits** ; ``up`` et ``session`` **créent un serveur facturé**.
@ -131,11 +132,27 @@ et montre exactement ce qui serait commandé :
.. code-block:: text
$ scripts/lab-host.sh plan
== offre : EM-B212X-SSD (ddaf8ba6-b2b2-4279-8af3-51930fb602f8), facturation hourly, stock available
== prix : 0.321 EUR HT par heure, frais de mise en service 0 EUR
!! fr-par-1 : offre EM-B420E-NVME en rupture de stock en fr-par-1
!! fr-par-2 : offre EM-B420E-NVME en rupture de stock en fr-par-2
!! nl-ams-1 : offre horaire EM-B420E-NVME : 0 correspondance(s) en nl-ams-1, une seule attendue
== zone : nl-ams-2
== offre : EM-B420E-NVME (d14eef5e-3279-42db-bb57-bb2bbe6a5b28), AMD EPYC 7272, facturation hourly, stock available
== prix : 0.444 EUR HT par heure, frais de mise en service 0 EUR
== os : Debian 12 (Bookworm) (83640d93-a0b8-45ad-9c9f-30cae48380a4), utilisateur root
== clés : 2 clé(s) SSH du projet
== requête : POST /baremetal/v1/zones/fr-par-1/servers
== requête : POST /baremetal/v1/zones/nl-ams-2/servers
**Offre et zone.** L'offre par défaut est ``EM-B420E-NVME`` (AMD EPYC 7272, 12 cœurs, 119 Gio) :
son modèle de CPU est exact et atteint **x86-64-v3**, le minimum de RHEL 10 et Rocky 10. Les offres
« Xeon … or equivalent » ne garantissent rien : ``EM-B212X-SSD`` (« E5-2620 v4 or equivalent ») a
livré le 2026-10-11 un E5-2670 de 2012, x86-64-v2, sur lequel Rocky 10 ne démarre pas.
``prepare`` refuse donc un serveur sans x86-64-v3 — dans une ``session``, il est aussitôt
supprimé. La zone n'est pas imposée : ``plan`` et ``up`` prennent la première zone de
``LAB_ZONES`` (par défaut toutes les zones Elastic Metal) où l'offre est en stock, ``SCW_DEFAULT_ZONE``
passant en tête ; ``status`` et ``down`` couvrent toutes ces zones. Une zone dont la liste échoue
est signalée sans masquer les autres : ``status`` affiche ce qui a répondu, ``down`` supprime les
serveurs listés, et tous deux sortent en erreur ; ``up`` refuse de créer tant qu'une zone reste
inconnue.
``session`` est la forme normale d'usage : le serveur est supprimé à la fin, que la commande
réussisse, échoue, ou que la session soit interrompue (Ctrl-C, ``TERM``, fermeture du terminal).
@ -231,12 +248,14 @@ Ce que le fichier déclare :
* ``frr`` — le chemin d'un ``frr.conf``, relatif au fichier de topologie : FRR est installé
au démarrage et la configuration déposée **telle quelle** (voir `Rôles`_).
* ``release`` — **obligatoire pour un hyperviseur**, refusé ailleurs : le tag de la release de
two que ``deploy.sh`` installe (``release: 0.2.0rc003``). Sans lui, ``deploy.sh`` prendrait la
two que ``deploy.sh`` installe (``release: 0.2.0rc008``). Sans lui, ``deploy.sh`` prendrait la
dernière release, et le lab ne serait plus reproductible.
* ``agent`` — pour un hyperviseur seulement : le chemin d'un ``agent.yml``, relatif au fichier
de topologie, déposé dans ``/etc/two/agent.yml`` avant ``deploy.sh``. Sans lui, l'agent tourne
avec sa configuration par défaut. L'exemple met hv1 sur le serveur DHCP intégré
(``test/e2e/topologies/agent/two.yml`` : ``dhcp.backend: two``) et laisse hv2 sur dnsmasq.
avec sa configuration par défaut. Les deux fichiers fournis donnent à l'agent la section
``bgp`` (AS 64600, route reflector ``10.255.255.1``) et un watchdog toutes les 10 s ;
``test/e2e/topologies/agent/two.yml`` met en plus hv1 sur le serveur DHCP intégré
(``dhcp.backend: two``), ``agent/bgp.yml`` laisse les autres sur dnsmasq.
``mgmt0`` et ``lo1`` sont réservés : aucun segment ne peut porter ces noms.
@ -286,8 +305,8 @@ Limites : 1000 nœuds, 256 segments, et autant de câbles que la plage UDP le pe
name loopback secondary frr release agent
sw1 - underlay 169.254.0.1/28 sw1.conf - -
rr1 lo1 10.255.255.1/32 underlay 169.254.0.3/28 rr1.conf - -
hv1 - - hv1.conf 0.2.0rc003 two.yml
hv2 - - hv2.conf 0.2.0rc003 -
hv1 - - hv1.conf 0.2.0rc008 two.yml
hv2 - - hv2.conf 0.2.0rc008 bgp.yml
segment underlay: 192.168.14.0/24, mtu 9000, switch sw1, bridge br-underlay, gateway 192.168.14.1
node interface address mac udp switch port mac udp
@ -319,7 +338,9 @@ Rôles
Les configurations FRR du lab vivent dans ``test/e2e/topologies/frr/``, une par nœud, **écrites à la main** :
ce sont les mêmes fichiers que la documentation de déploiement inclut, pour que le lab qualifie
exactement ce qu'elle prescrit. Celle du route reflector :
exactement ce qu'elle prescrit. Celles des hyperviseurs se réduisent à ``hostname`` et ``log`` :
la configuration BGP est posée par l'agent (section ``bgp`` de ``agent.yml``). Celle du route
reflector :
.. literalinclude:: ../../test/e2e/topologies/frr/rr1.conf
:language: text
@ -357,7 +378,12 @@ teste les scripts de sa branche. L'uplink ``-u`` est l'interface qui porte la ro
celle du premier segment de l'hyperviseur dans l'ordre de déclaration des segments — parce que
``deploy.sh`` y lit l'adresse et la passerelle qu'il déplace sur ``br-000000``. ``deploy.sh``
télécharge la release sur ``git.g3e.fr`` sans réessayer : le lancement attend d'abord que le serveur
réponde, à travers le switch. FRR est installé **après** : il démarre sur le réseau final.
réponde, à travers le switch. FRR est installé **après** : il démarre sur le réseau final. Démarré
avant la migration, zebra peut perdre la route par défaut quand elle passe de l'uplink à
``br-000000`` — constaté le 2026-10-11 sur un hyperviseur sur deux : route reflector
``unresolved``, session BGP jamais établie. L'agent, configuré avec une section ``bgp``, refuse de
démarrer tant que FRR n'est pas là : son premier démarrage par ``deploy.sh`` échoue, et le
provisionnement le **redémarre** une fois FRR installé.
**Un seul script de provisionnement par nœud.** cloud-init exécute ``runcmd`` comme un script
``sh`` sans ``set -e`` : seule la dernière commande compte, et un ``deploy.sh`` en échec suivi d'un
@ -717,6 +743,30 @@ sortie vaut 1 si une vérification échoue **ou si aucune n'a été faite**.
le trafic restant est **mesuré** (``INFO``) à 30 et 90 s ; au retour du route reflector, le
VTEP distant est réappris et le trafic repasse — délai mesuré
- hv1, hv2, rr1
* - ``s7-l3vni``
- qualification de `#41 <https://git.g3e.fr/syonad/two/issues/41>`_ **par l'API** : VPC créées
avec une ``l3vni``, l'agent pose VRF, L3VNI, transit, FRR et les routes de type 5 (``/24``
des subnets, ``/32`` des VM). Deux subnets d'une même VPC, chacun sur un seul hyperviseur,
se joignent par le L3VNI à travers le route reflector inchangé ; 1472 octets en ``-M do`` ;
une seconde VPC de même plage sur un autre L3VNI n'est ni importée ni jointe ; L3VNI déjà
prise refusée ; forwarding de l'hôte limité aux interfaces de la VRF ; suppression d'un
subnet refusée tant qu'une VM l'utilise ; démontage complet d'une VPC sans redémarrage de
bgpd
- hv1, hv2, rr1
* - ``s8-l3vni-migration``
- suite de ``s7``, topologie ``evpn-3hv.yml`` : migration d'une VM de hv1 vers hv2 par l'API,
observée depuis hv3 qui n'a pas le subnet : migration simple (VM supprimée puis recréée,
``/24`` comme filet), séquence orchestrée (deux VM de même IP, deux ``/32`` en ECMP, 40
sources sur 40) ; l'ancien « pire cas » devient un refus (409) ; MAC de gateway propre à
chaque hôte, sans doublon EVPN ; watchdog : ``/32`` orphelin signalé comme trou noir, ``/32`` manquant
signalé
- hv1, hv2, hv3, rr1
* - ``s9-subnets-partages``
- deux VPC, avec et sans ``l3vni``, chacune avec deux subnets présents sur **les deux**
hyperviseurs et une VM par subnet et par hôte : ping entre toutes les paires (même subnet ou
non, même hôte ou non) ; chaque VM voit la MAC de gateway de son propre hôte ; aucune MAC en
double sur les quatre VNI
- hv2, hv3, rr1
``s6`` réutilise les VM de ``s4`` : le lancer après.
@ -724,7 +774,9 @@ sortie vaut 1 si une vérification échoue **ou si aucune n'a été faite**.
scénario envoie des blocs de shell aux nœuds par ``on <nœud> [VAR=valeur…] <<'NODE'``, précédés de
``test/e2e/lib/node.sh`` — appels à l'API de l'agent, attente des états, image Debian compatible two
(préparée une fois par hyperviseur, ``seedfrom`` avec barre oblique finale), clé SSH des VM,
``check`` et ``vm_fails``. Une vérification négative (« ne joint pas ») passe par ``vm_fails`` :
``check`` et ``vm_fails`` ; pour #41, ``vpc_create`` avec une ``l3vni``, ``api_code`` (code HTTP
d'un refus attendu), l'observation des VRF et de BGP (``vrf_nexthops``, ``bgp_paths``,
``wait_l3vni``…) et ``wait_watchdog`` (alerte du watchdog dans le journal de l'agent). Une vérification négative (« ne joint pas ») passe par ``vm_fails`` :
elle n'est réussie que si le SSH vers la VM a fonctionné **et** que la commande y a échoué — un
SSH en panne ne passe jamais pour une isolation.
@ -751,6 +803,77 @@ dérive la MAC du rang de l'IP, et les VM ``.10``/``.11`` des deux subnets avaie
Vérifié à la main sur le lab, chaque serveur DHCP ne connaissait que les couples MAC/IP de son
subnet ; le scénario compare désormais ces couples.
``s7-l3vni`` le 2026-10-05, même lab, FRR 10.7.1 : **46 réussi(s), 0 échoué(s)** au dernier run.
Quatre constats pour #41, au-delà du routage inter-subnet qui fonctionne avec le route reflector
inchangé :
* **bgpd 10.7.1 plante** (SIGSEGV dans ``bgp_redistribute_add``) quand la VRF du noyau est
supprimée puis recréée sous une instance ``router bgp … vrf`` encore configurée — FRR refuse de
supprimer l'instance tant que ``vni`` est déclaré dans la VRF (« Please unconfigure l3vni »).
Le plantage a touché les deux hyperviseurs à une seconde d'intervalle. Avec le démontage dans
l'ordre — ``no redistribute``, ``no vni``, ``no router bgp … vrf``, puis le noyau —, trois runs
consécutifs passent sans plantage.
* **La configuration posée par vtysh est perdue** au redémarrage de bgpd par watchfrr, qui
relit ``frr.conf`` seul.
* **Le transit** ``169.254.0.0/30``, **identique sur tous les hôtes**, fait rejeter comme
« martiens » les ICMP émis par les sauts distants (VRF et netns de l'hôte de sortie) : le
noyau de l'hôte d'entrée possède la même adresse. Quatre routeurs sur le chemin, seuls les
deux premiers répondent. Même effet attendu sur un ICMP « fragmentation nécessaire ».
* **La route du supernet n'existe pas dans le netns** de la VPC avant la pose manuelle (premier
run, lab neuf) : two ne pose que la route connectée du subnet.
``s8-l3vni-migration`` le 2026-10-06, ``evpn-3hv.yml`` : **61 réussi(s), 0 échoué(s)**. Le filet du
``/24`` porte le trafic tant que la destination n'a pas annoncé son ``/32`` ; deux ``/32``
coexistent sans perte tant que la source garde le subnet (40 sources sur 40, relais en L2). Si la
source supprime le subnet avant de retirer son ``/32``, le trou noir est **stable mais partiel** :
hv3 installe les deux chemins en ECMP, et seuls les flux hachés vers la source échouent (17 sources
sur 40) — invisible avec un seul émetteur.
Le 2026-10-11, les mêmes qualifications **par l'API**, l'agent posant toute la configuration
(FRR 10.7.1) :
* ``s1`` à ``s6`` sur ``evpn-2hv.yml``, release ``0.2.0rc004``, base BGP des hyperviseurs posée par
l'agent : 37, 22, 12, 14, 13 et 8 réussis, aucun échec.
* Puis, release ``0.2.0rc005`` (correction du démontage FRR, ci-dessous), ``evpn-3hv.yml`` :
* ``s7-l3vni`` : **52 réussi(s), 1 échoué(s)**. Routage inter-subnet par le
L3VNI, MAC de routeur dérivée du VTEP, exports ``/24`` et ``/32`` automatiques, forwarding par
interface, L3VNI en double et subnet utilisé refusés (409), démontage complet d'une VPC sans
redémarrage de bgpd. L'échec — « TTL 1 », un seul paquet — ne s'est pas reproduit au run
précédent : probablement le débit limité des ICMP du noyau ; la vérification envoie désormais
trois paquets.
* ``s8-l3vni-migration`` : **48 réussi(s), 1 échoué(s)**. Migration simple (``/32`` de la
destination installé sur hv3 sans délai mesurable, 50/50), séquence orchestrée (deux ``/32`` en
ECMP, 40 sources sur 40), ex-pire cas refusé (409), watchdog : ``/32`` orphelin signalé comme
trou noir, ``/32`` manquant signalé. L'échec est un constat : **la MAC de gateway anycast est
annoncée en EVPN** (route de type 2 sur rr1) et FRR la déclare en double sur la VNI du subnet
porté par deux hyperviseurs — apprise sur le veth du subnet, numéros de séquence croissants.
Trois défauts trouvés et corrigés pendant la campagne :
* **FRR installé avant la migration réseau** : zebra a perdu la route par défaut sur un
hyperviseur sur deux (route reflector ``unresolved``). Retour à l'ordre « FRR après
``deploy.sh`` », puis redémarrage de l'agent (voir `Rôles`_).
* **Remarques de vtysh prises pour des erreurs** : ``no vni`` répond
``% Configuration applied with notes:`` avec un code de retour 0. Une vraie erreur (commande
inconnue, refus) sort en 1.
* **L3VNI libérée de façon asynchrone** : juste après ``no vni``, ``no router bgp … vrf`` peut être
refusé (« Please unconfigure l3vni ») puis accepté un instant plus tard ; l'agent réessaie.
Le 2026-10-12, release ``0.2.0rc006``, ``evpn-3hv.yml`` : ``s1`` à ``s7`` sans échec,
``s8-l3vni-migration`` **50 réussi(s), 0 échoué(s)** (MAC de gateway propre à chaque hôte, aucun
doublon EVPN), ``s9-subnets-partages`` **75 réussi(s), 1 échoué(s)**. L'échec est une session SSH
coupée (``Broken pipe``), pas un ping perdu : quand un hôte route vers une VM d'un autre hôte, son
netns émet une requête ARP au nom de la gateway, partagée par tous les hôtes ; la VM met son cache à
jour et, pendant ~8 s, envoie à la gateway de l'autre hôte ce qui était destiné à la sienne.
Détails et suite : `#57 <https://git.g3e.fr/syonad/two/issues/57>`_.
.. note::
Un ``Broken pipe`` (``client_loop: send disconnect``) ou une session SSH figée dans un scénario
n'est **pas forcément un aléa du lab** : c'est la signature de ce problème. Ne pas le classer
comme test instable ni ajouter un nouvel essai qui le masquerait ; regarder d'abord le cache ARP
de la VM (``ip neigh show <gateway>``) et l'état de la session côté VM.
Les VM sont accessibles depuis le netns de leur VPC, sur l'hyperviseur, avec l'utilisateur
``syonad`` créé par les métadonnées de two :

View file

@ -71,7 +71,8 @@ Codes de retour
- ressource inexistante
* - ``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
ne l'autorise pas ; pour un VPC, subnets encore présents ; pour un subnet, VM non
supprimées qui l'utilisent encore
* - ``422``
- dépendance absente ou pas prête : VPC parent d'un subnet, subnet d'une VM
* - ``500``

View file

@ -104,6 +104,38 @@ Traduit les clés logiques ``iface_type`` de l'API vers les bridges physiques de
inconnue ou omise retombe silencieusement sur ``default_interface`` — ce n'est pas une erreur,
mais c'est une source de subnets branchés au mauvais endroit sans le dire.
Plan de contrôle BGP
--------------------
.. code-block:: yaml
bgp:
asn: 64600
route_reflectors: [10.255.255.1]
Section **facultative**. Absente, l'agent ne touche pas à FRR : sa configuration reste à poser
à la main, comme avant. Présente, l'agent **pilote la configuration BGP de l'hyperviseur** :
à chaque démarrage, avant d'ouvrir son API, il applique par ``vtysh`` la base décrite dans
:doc:`/deploiement/premier-hyperviseur`, puis l'enregistre par ``write memory``.
* ``asn`` — l'AS de l'hyperviseur, commun à tous les hyperviseurs du cluster (iBGP vers le
route reflector). Obligatoire dès que la section existe.
* ``route_reflectors`` — au moins une adresse IPv4, sans doublon. Un route reflector retiré de
la liste est retiré de FRR au démarrage suivant.
Le ``router-id`` n'est pas configurable : c'est l'adresse IPv4 primaire de
``default_interface``, celle qui sert de VTEP.
Le démarrage **échoue** si la section est incomplète, si ``default_interface`` n'a pas
d'adresse IPv4 primaire, si ``vtysh`` refuse une commande, ou si FRR tourne déjà sous un autre
AS : changer d'``asn`` suppose de retirer l'ancienne instance à la main.
.. warning::
``/etc/frr/frr.conf`` devient un fichier **généré** : ``write memory`` le réécrit à partir de
la configuration en mémoire de FRR. Une modification faite dans le fichier sans être
rechargée est perdue au prochain démarrage de l'agent.
Metadata et QEMU
----------------

View file

@ -38,6 +38,21 @@ toujours sur le système, et **notifie les écarts sans jamais réparer**.
Il contrôle notamment l'existence des network namespaces, des liens réseau des subnets, des taps
de VM et la réponse des units systemd associées.
Avec une section ``bgp`` dans la configuration, il contrôle aussi le plan de contrôle :
* **Sessions BGP** : une notification par route reflector dont la session n'est pas
``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>``).
* **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`` —
est signalée comme un **trou noir** : l'annonce attire du trafic que plus rien ne reçoit.
Un VPC routé alors que la section ``bgp`` a disparu de la configuration est signalé lui aussi. Il
reste supprimable : le démontage lit l'AS de son instance dans la configuration courante de FRR.
.. note::
Un écart persistant est signalé **à chaque tick**, sans déduplication. Le volume de

View file

@ -16,11 +16,15 @@ import (
// The worker queue is buffered but has no running goroutines: Dispatch enqueues
// without blocking and Execute never runs, so DB state reflects only Prepare writes.
func newTestServer(t *testing.T) (*Server, *badger.DB) {
t.Helper()
return newTestServerWith(t, &configuration.Config{DefaultInterface: "br-test"})
}
func newTestServerWith(t *testing.T, cfg *configuration.Config) (*Server, *badger.DB) {
t.Helper()
db := kv.InitDB(kv.Config{Path: t.TempDir()}, false)
t.Cleanup(func() { db.Close() })
q := worker.New(100)
cfg := &configuration.Config{DefaultInterface: "br-test"}
logger := slog.New(slog.NewTextHandler(io.Discard, nil))
d := dispatcher.New(q, db, cfg, logger)
return New(d, db, logger, "127.0.0.1:0"), db

View file

@ -1,14 +1,16 @@
package agentapi
type VPCCreateRequest struct {
Name string `json:"name"`
CIDR string `json:"cidr"`
Name string `json:"name"`
CIDR string `json:"cidr"`
L3VNI *uint32 `json:"l3vni,omitempty"`
}
type VPC struct {
Name string `json:"name"`
State string `json:"state"`
CIDR string `json:"cidr"`
L3VNI uint32 `json:"l3vni,omitempty"`
}
type SubnetCreateRequest struct {

View file

@ -36,8 +36,9 @@ func (s *Server) getVpc(w http.ResponseWriter, _ *http.Request, name string) {
return
}
cidr, _ := kv.GetFromDB(s.db, "vpc/"+name+"/cidr")
l3vni, _ := kv.GetFromDB(s.db, "vpc/"+name+"/l3vni")
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(VPC{Name: name, State: state, CIDR: cidr})
json.NewEncoder(w).Encode(VPC{Name: name, State: state, CIDR: cidr, L3VNI: parseL3VNI(l3vni)})
}
func (s *Server) deleteVpc(w http.ResponseWriter, _ *http.Request, name string) {

View file

@ -5,9 +5,12 @@ import (
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/pkg/db/kv"
"github.com/dgraph-io/badger/v4"
)
// --- VpcsHandler ---
@ -236,3 +239,85 @@ func TestVpcByName_InvalidMethod(t *testing.T) {
t.Errorf("attendu 405, obtenu %d", w.Code)
}
}
func newBGPTestServer(t *testing.T) (*Server, *badger.DB) {
cfg := &configuration.Config{DefaultInterface: "br-test"}
cfg.BGP.ASN = 64600
cfg.BGP.RouteReflectors = []string{"10.255.255.1"}
return newTestServerWith(t, cfg)
}
func postVpcJSON(s *Server, body string) *httptest.ResponseRecorder {
w := httptest.NewRecorder()
s.VpcsHandler(w, httptest.NewRequest(http.MethodPost, "/vpcs", strings.NewReader(body)))
return w
}
func TestPostVpc_WithL3VNI(t *testing.T) {
s, db := newBGPTestServer(t)
w := postVpcJSON(s, `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":4001}`)
if w.Code != http.StatusAccepted {
t.Fatalf("attendu 202, obtenu %d: %s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), `"l3vni":4001`) {
t.Errorf("réponse sans l3vni : %s", w.Body.String())
}
if got, _ := kv.GetFromDB(db, "vpc/vp-1/l3vni"); got != "4001" {
t.Errorf("l3vni en DB = %q", got)
}
}
func TestPostVpc_WithoutL3VNIOmitsTheField(t *testing.T) {
s, _ := newBGPTestServer(t)
w := postVpcJSON(s, `{"name":"vp-1","cidr":"10.0.0.0/16"}`)
if w.Code != http.StatusAccepted || strings.Contains(w.Body.String(), "l3vni") {
t.Errorf("%d : %s", w.Code, w.Body.String())
}
}
func TestPostVpc_RejectsAnInvalidL3VNIAsABadRequest(t *testing.T) {
s, db := newBGPTestServer(t)
for _, body := range []string{
`{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":0}`,
`{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":255}`,
`{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":65536}`,
`{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":16777216}`,
`{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":-1}`,
} {
if w := postVpcJSON(s, body); w.Code != http.StatusBadRequest {
t.Errorf("%s : attendu 400, obtenu %d: %s", body, w.Code, w.Body.String())
}
}
if entries, _ := kv.ListByPrefix(db, "vpc/"); len(entries) != 0 {
t.Errorf("écritures malgré le refus : %v", entries)
}
}
func TestPostVpc_L3VNIWithoutBGPIsAConflict(t *testing.T) {
s, _ := newTestServer(t)
w := postVpcJSON(s, `{"name":"vp-1","cidr":"10.0.0.0/16","l3vni":4001}`)
if w.Code != http.StatusConflict || !strings.Contains(w.Body.String(), "requires the bgp section") {
t.Errorf("%d : %s", w.Code, w.Body.String())
}
}
func TestGetAndListVpc_ReturnTheL3VNI(t *testing.T) {
s, db := newTestServer(t)
kv.AddInDB(db, "vpc/vp-1/state", "running")
kv.AddInDB(db, "vpc/vp-1/cidr", "10.0.0.0/16")
kv.AddInDB(db, "vpc/vp-1/l3vni", "4001")
w := httptest.NewRecorder()
s.VpcByNameHandler(w, httptest.NewRequest(http.MethodGet, "/vpcs/vp-1", nil))
var got VPC
json.NewDecoder(w.Body).Decode(&got)
if got.L3VNI != 4001 {
t.Errorf("GET : l3vni = %d", got.L3VNI)
}
w = httptest.NewRecorder()
s.VpcsHandler(w, httptest.NewRequest(http.MethodGet, "/vpcs", nil))
var list []VPC
json.NewDecoder(w.Body).Decode(&list)
if len(list) != 1 || list[0].L3VNI != 4001 {
t.Errorf("liste : %+v", list)
}
}

View file

@ -4,9 +4,11 @@ import (
"encoding/json"
"net"
"net/http"
"strconv"
"strings"
dispatcher "git.g3e.fr/syonad/two/internal/dispatcher/agent"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/pkg/db/kv"
)
@ -44,6 +46,8 @@ func (s *Server) listVpcs(w http.ResponseWriter, _ *http.Request) {
vpcs[name].State = value
case "cidr":
vpcs[name].CIDR = value
case "l3vni":
vpcs[name].L3VNI = parseL3VNI(value)
}
}
result := make([]VPC, 0, len(vpcs))
@ -77,6 +81,14 @@ func (s *Server) postVpc(w http.ResponseWriter, r *http.Request) {
return
}
cmd := dispatcher.CreateVPCCommand{Name: req.Name, CIDR: req.CIDR}
if req.L3VNI != nil {
if err := l3vni.Valid(*req.L3VNI); err != nil {
w.WriteHeader(http.StatusBadRequest)
json.NewEncoder(w).Encode(ErrorResponse{Error: err.Error()})
return
}
cmd.L3VNI = *req.L3VNI
}
if err := s.dispatcher.Prepare(cmd); err != nil {
w.WriteHeader(http.StatusConflict)
json.NewEncoder(w).Encode(ErrorResponse{Error: err.Error()})
@ -90,5 +102,10 @@ func (s *Server) postVpc(w http.ResponseWriter, r *http.Request) {
return
}
w.WriteHeader(http.StatusAccepted)
json.NewEncoder(w).Encode(VPC{Name: req.Name, State: state, CIDR: req.CIDR})
json.NewEncoder(w).Encode(VPC{Name: req.Name, State: state, CIDR: req.CIDR, L3VNI: cmd.L3VNI})
}
func parseL3VNI(value string) uint32 {
id, _ := strconv.ParseUint(value, 10, 32)
return uint32(id)
}

View file

@ -0,0 +1,38 @@
package configuration
import (
"fmt"
"net"
)
type BGP struct {
ASN uint32 `mapstructure:"asn"`
RouteReflectors []string `mapstructure:"route_reflectors"`
}
func (b BGP) Enabled() bool {
return b.ASN != 0 || len(b.RouteReflectors) > 0
}
func (b BGP) Reflectors() ([]net.IP, error) {
if b.ASN == 0 {
return nil, fmt.Errorf("bgp.asn must be set")
}
if len(b.RouteReflectors) == 0 {
return nil, fmt.Errorf("bgp.route_reflectors must list at least one address")
}
seen := make(map[string]bool, len(b.RouteReflectors))
ips := make([]net.IP, 0, len(b.RouteReflectors))
for _, rr := range b.RouteReflectors {
ip := net.ParseIP(rr).To4()
if ip == nil {
return nil, fmt.Errorf("bgp.route_reflectors: %q is not an IPv4 address", rr)
}
if seen[ip.String()] {
return nil, fmt.Errorf("bgp.route_reflectors: %s is listed twice", ip)
}
seen[ip.String()] = true
ips = append(ips, ip)
}
return ips, nil
}

View file

@ -0,0 +1,54 @@
package configuration
import (
"strings"
"testing"
)
func TestLoadConfig_BGPAbsentIsDisabled(t *testing.T) {
cfg, err := LoadConfig(writeConfig(t, "database:\n path: /tmp/two\n"))
if err != nil {
t.Fatalf("LoadConfig: %v", err)
}
if cfg.BGP.Enabled() {
t.Errorf("bgp enabled without a bgp section: %+v", cfg.BGP)
}
}
func TestLoadConfig_ReadsTheBGPSection(t *testing.T) {
cfg, err := LoadConfig(writeConfig(t, "bgp:\n asn: 4200000000\n route_reflectors: [10.255.255.1, 10.255.255.2]\n"))
if err != nil {
t.Fatalf("LoadConfig: %v", err)
}
if !cfg.BGP.Enabled() || cfg.BGP.ASN != 4200000000 {
t.Fatalf("bgp = %+v", cfg.BGP)
}
rrs, err := cfg.BGP.Reflectors()
if err != nil {
t.Fatalf("Reflectors: %v", err)
}
if len(rrs) != 2 || rrs[0].String() != "10.255.255.1" || rrs[1].String() != "10.255.255.2" {
t.Errorf("reflectors = %v", rrs)
}
}
func TestBGPReflectors_RejectsAnIncompleteOrInvalidSection(t *testing.T) {
cases := []struct {
bgp BGP
want string
}{
{BGP{RouteReflectors: []string{"10.255.255.1"}}, "bgp.asn must be set"},
{BGP{ASN: 64600}, "at least one address"},
{BGP{ASN: 64600, RouteReflectors: []string{"rr1"}}, `"rr1" is not an IPv4 address`},
{BGP{ASN: 64600, RouteReflectors: []string{"fd00::1"}}, `"fd00::1" is not an IPv4 address`},
{BGP{ASN: 64600, RouteReflectors: []string{"10.255.255.1", "10.255.255.1"}}, "10.255.255.1 is listed twice"},
}
for _, c := range cases {
if !c.bgp.Enabled() {
t.Errorf("%+v: Enabled() = false", c.bgp)
}
if _, err := c.bgp.Reflectors(); err == nil || !strings.Contains(err.Error(), c.want) {
t.Errorf("%+v: erreur %v, attendu %q", c.bgp, err, c.want)
}
}
}

View file

@ -55,6 +55,7 @@ type Config struct {
Enabled bool `mapstructure:"enabled"`
IntervalSeconds int `mapstructure:"interval_seconds"`
} `mapstructure:"watchdog"`
BGP BGP `mapstructure:"bgp"`
DefaultInterface string `mapstructure:"default_interface"`
Interfaces map[string]string `mapstructure:"interfaces"`
}

View file

@ -17,6 +17,7 @@ func newTestDispatcher(t *testing.T) (*Dispatcher, *badger.DB) {
t.Cleanup(func() { db.Close() })
q := worker.New(100)
q.Start(2)
t.Cleanup(q.Stop)
cfg := &configuration.Config{DefaultInterface: "br-default"}
cfg.Interfaces = map[string]string{"vms": "br-vms"}
logger := slog.New(slog.NewTextHandler(io.Discard, nil))

View file

@ -2,7 +2,9 @@ package dispatcher
import (
"fmt"
"sort"
"strconv"
"strings"
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
@ -101,9 +103,36 @@ func (c DeleteSubnetCommand) Prepare(db *badger.DB, _ *configuration.Config) err
if !state.CanDelete(current) {
return fmt.Errorf("subnet %q cannot be deleted while %s", c.Name, current)
}
vms, err := vmsUsingSubnet(db, c.Name)
if err != nil {
return err
}
if len(vms) > 0 {
return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(vms, ", "))
}
return state.Set(db, c.Key(), state.Deleting)
}
func vmsUsingSubnet(db *badger.DB, subnetName string) ([]string, error) {
entries, err := kv.ListByPrefix(db, "vm/")
if err != nil {
return nil, fmt.Errorf("failed to list vms: %w", err)
}
var users []string
for key, value := range entries {
parts := strings.Split(key, "/")
if len(parts) != 5 || parts[2] != "nic" || parts[4] != "subnet" || value != subnetName {
continue
}
if s, err := state.Get(db, "vm/"+parts[1]); err == nil && s == state.Deleted {
continue
}
users = append(users, parts[1])
}
sort.Strings(users)
return users, nil
}
func (c DeleteSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
if err := subnet.DeleteSubnet(db, c.Name, cfg); err != nil {
return err

View file

@ -1,6 +1,7 @@
package dispatcher
import (
"strings"
"testing"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
@ -327,3 +328,38 @@ func TestCreateSubnetCommand_Prepare_RejectsUnknownMode(t *testing.T) {
t.Error("un mode inconnu doit être refusé")
}
}
func TestDeleteSubnetCommand_Prepare_RefusedWhileAVMUsesIt(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-a/state", "running")
kv.AddInDB(db, "vm/i-gone/state", "deleted")
kv.AddInDB(db, "vm/i-gone/nic/0/subnet", "sn-a")
kv.AddInDB(db, "vm/i-other/state", "running")
kv.AddInDB(db, "vm/i-other/nic/0/subnet", "sn-b")
kv.AddInDB(db, "vm/i-b/state", "deleting")
kv.AddInDB(db, "vm/i-b/nic/0/subnet", "sn-b")
kv.AddInDB(db, "vm/i-b/nic/1/subnet", "sn-a")
kv.AddInDB(db, "vm/i-a/state", "error")
kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a")
kv.AddInDB(db, "vm/i-c/state", "running")
kv.AddInDB(db, "vm/i-c/nic/0/subnet", "sn-a")
err := DeleteSubnetCommand{Name: "sn-a"}.Prepare(db, nil)
if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-b, i-c`) {
t.Fatalf("erreur %v", err)
}
if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "running" {
t.Errorf("état modifié malgré le refus : %q", s)
}
}
func TestDeleteSubnetCommand_Prepare_AllowedOnceItsVMsAreDeleted(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-a/state", "running")
kv.AddInDB(db, "vm/i-gone/state", "deleted")
kv.AddInDB(db, "vm/i-gone/nic/0/subnet", "sn-a")
kv.AddInDB(db, "vm/i-other/state", "running")
kv.AddInDB(db, "vm/i-other/nic/0/subnet", "sn-b")
if err := (DeleteSubnetCommand{Name: "sn-a"}).Prepare(db, nil); err != nil {
t.Fatalf("Prepare a échoué : %v", err)
}
}

View file

@ -3,10 +3,12 @@ package dispatcher
import (
"fmt"
"net"
"strconv"
"strings"
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/internal/state"
"git.g3e.fr/syonad/two/internal/vpc"
"git.g3e.fr/syonad/two/pkg/db/kv"
@ -14,27 +16,63 @@ import (
)
type CreateVPCCommand struct {
Name string
CIDR string
Name string
CIDR string
L3VNI uint32
}
func (c CreateVPCCommand) Key() string { return "vpc/" + c.Name }
func (c CreateVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error {
func (c CreateVPCCommand) Prepare(db *badger.DB, cfg *configuration.Config) error {
if _, err := kv.GetFromDB(db, "vpc/"+c.Name+"/state"); err == nil {
return fmt.Errorf("vpc %q already exists", c.Name)
}
if _, _, err := net.ParseCIDR(c.CIDR); err != nil {
return fmt.Errorf("invalid cidr %q: %w", c.CIDR, err)
}
if c.L3VNI != 0 {
if err := c.checkL3VNI(db, cfg); err != nil {
return err
}
}
if err := kv.AddInDB(db, "vpc/"+c.Name+"/cidr", c.CIDR); err != nil {
return err
}
if c.L3VNI != 0 {
if err := kv.AddInDB(db, "vpc/"+c.Name+"/l3vni", strconv.FormatUint(uint64(c.L3VNI), 10)); err != nil {
return err
}
}
return state.Set(db, c.Key(), state.Creating)
}
func (c CreateVPCCommand) Execute(db *badger.DB, _ *configuration.Config) error {
return vpc.CreateVPC(db, c.Name)
func (c CreateVPCCommand) checkL3VNI(db *badger.DB, cfg *configuration.Config) error {
if err := l3vni.Valid(c.L3VNI); err != nil {
return err
}
if cfg == nil || !cfg.BGP.Enabled() {
return fmt.Errorf("l3vni requires the bgp section in the agent configuration")
}
entries, err := kv.ListByPrefix(db, "vpc/")
if err != nil {
return fmt.Errorf("failed to list vpcs: %w", err)
}
want := strconv.FormatUint(uint64(c.L3VNI), 10)
for key, value := range entries {
parts := strings.Split(key, "/")
if len(parts) != 3 || parts[2] != "l3vni" || value != want {
continue
}
if s, err := state.Get(db, "vpc/"+parts[1]); err == nil && s == state.Deleted {
continue
}
return fmt.Errorf("l3vni %d is already used by vpc %q", c.L3VNI, parts[1])
}
return nil
}
func (c CreateVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
return vpc.CreateVPC(db, c.Name, cfg)
}
type DeleteVPCCommand struct {

View file

@ -1,8 +1,10 @@
package dispatcher
import (
"strings"
"testing"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/pkg/db/kv"
)
@ -137,3 +139,81 @@ func TestDeleteVPCCommand_Prepare_AllowedWhenSubnetDeleting(t *testing.T) {
t.Fatalf("Prepare devrait réussir si le subnet est deleting : %v", err)
}
}
func bgpConfig() *configuration.Config {
cfg := &configuration.Config{}
cfg.BGP.ASN = 64600
cfg.BGP.RouteReflectors = []string{"10.255.255.1"}
return cfg
}
func TestCreateVPCCommand_Prepare_StoresTheL3VNI(t *testing.T) {
_, db := newTestDispatcher(t)
cmd := CreateVPCCommand{Name: "vpc-1", CIDR: "10.0.0.0/16", L3VNI: 4001}
if err := cmd.Prepare(db, bgpConfig()); err != nil {
t.Fatalf("Prepare a échoué : %v", err)
}
if got, err := kv.GetFromDB(db, "vpc/vpc-1/l3vni"); err != nil || got != "4001" {
t.Errorf("l3vni en DB = %q, %v ; attendu 4001", got, err)
}
}
func TestCreateVPCCommand_Prepare_WithoutL3VNIStoresNothing(t *testing.T) {
_, db := newTestDispatcher(t)
cmd := CreateVPCCommand{Name: "vpc-1", CIDR: "10.0.0.0/16"}
if err := cmd.Prepare(db, nil); err != nil {
t.Fatalf("Prepare a échoué : %v", err)
}
if got, err := kv.GetFromDB(db, "vpc/vpc-1/l3vni"); err == nil {
t.Errorf("clé l3vni écrite : %q", got)
}
}
func TestCreateVPCCommand_Prepare_RefusesAnL3VNIWithoutBGP(t *testing.T) {
_, db := newTestDispatcher(t)
cmd := CreateVPCCommand{Name: "vpc-1", CIDR: "10.0.0.0/16", L3VNI: 4001}
err := cmd.Prepare(db, &configuration.Config{})
if err == nil || !strings.Contains(err.Error(), "requires the bgp section") {
t.Fatalf("erreur %v", err)
}
if entries, _ := kv.ListByPrefix(db, "vpc/"); len(entries) != 0 {
t.Errorf("écritures malgré le refus : %v", entries)
}
}
func TestCreateVPCCommand_Prepare_RefusesAReservedL3VNI(t *testing.T) {
_, db := newTestDispatcher(t)
cmd := CreateVPCCommand{Name: "vpc-1", CIDR: "10.0.0.0/16", L3VNI: 254}
if err := cmd.Prepare(db, bgpConfig()); err == nil || !strings.Contains(err.Error(), "l3vni 254 is reserved") {
t.Fatalf("erreur %v", err)
}
if entries, _ := kv.ListByPrefix(db, "vpc/"); len(entries) != 0 {
t.Errorf("écritures malgré le refus : %v", entries)
}
}
func TestCreateVPCCommand_Prepare_RefusesAnL3VNIAlreadyUsed(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-a/state", "deleting")
kv.AddInDB(db, "vpc/vpc-a/l3vni", "4001")
cmd := CreateVPCCommand{Name: "vpc-b", CIDR: "10.0.0.0/16", L3VNI: 4001}
err := cmd.Prepare(db, bgpConfig())
if err == nil || !strings.Contains(err.Error(), `l3vni 4001 is already used by vpc "vpc-a"`) {
t.Fatalf("erreur %v", err)
}
if _, err := kv.GetFromDB(db, "vpc/vpc-b/state"); err == nil {
t.Error("vpc-b créé malgré le doublon")
}
}
func TestCreateVPCCommand_Prepare_ReusesTheL3VNIOfADeletedVPC(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-a/state", "deleted")
kv.AddInDB(db, "vpc/vpc-a/l3vni", "4001")
kv.AddInDB(db, "vpc/vpc-c/state", "running")
kv.AddInDB(db, "vpc/vpc-c/l3vni", "4002")
cmd := CreateVPCCommand{Name: "vpc-b", CIDR: "10.0.0.0/16", L3VNI: 4001}
if err := cmd.Prepare(db, bgpConfig()); err != nil {
t.Fatalf("Prepare a échoué : %v", err)
}
}

146
internal/frr/client.go Normal file
View file

@ -0,0 +1,146 @@
package frr
import (
"fmt"
"os/exec"
"strings"
"time"
)
const (
appliedWithNotes = "% Configuration applied with notes:"
l3vniStillBound = "% Please unconfigure l3vni"
l3vniRetries = 20
l3vniRetryDelay = 250 * time.Millisecond
)
type runner func(args ...string) ([]byte, error)
type Client struct {
run runner
sleep func(time.Duration)
}
func NewClient() *Client {
return &Client{
run: func(args ...string) ([]byte, error) {
return exec.Command("vtysh", args...).CombinedOutput()
},
sleep: time.Sleep,
}
}
func (c *Client) ApplyBase(b Base) error {
if err := b.validate(); err != nil {
return err
}
running, err := c.runningConfig()
if err != nil {
return err
}
stale, err := b.staleReflectors(running)
if err != nil {
return err
}
if err := c.configure(b.commands()...); err != nil {
return err
}
if len(stale) > 0 {
cmds := []string{fmt.Sprintf("router bgp %d", b.ASN)}
for _, rr := range stale {
cmds = append(cmds, "no neighbor "+rr)
}
if err := c.configure(append(cmds, "exit")...); err != nil {
return err
}
}
return c.save()
}
func (c *Client) ApplyVRF(v VRF) error {
if err := v.validate(); err != nil {
return err
}
if err := c.configure(v.commands()...); err != nil {
return err
}
return c.save()
}
func (c *Client) WithdrawVRF(v VRF) error {
return c.teardown(v, routingTeardown)
}
func (c *Client) RemoveVRF(v VRF) error {
if err := c.teardown(v, vrfTeardown); err != nil {
return err
}
running, err := c.runningConfig()
if err != nil {
return err
}
return remaining(routingTeardown(v, running))
}
func (c *Client) teardown(v VRF, plan func(VRF, string) []step) error {
if v.ID == "" {
return fmt.Errorf("frr: vrf id must not be empty")
}
running, err := c.runningConfig()
if err != nil {
return err
}
for _, s := range plan(v, running) {
if err := c.configureStep(s); err != nil {
return err
}
}
if err := c.save(); err != nil {
return err
}
if running, err = c.runningConfig(); err != nil {
return err
}
return remaining(plan(v, running))
}
func (c *Client) configureStep(s step) error {
err := c.configure(s...)
for i := 0; i < l3vniRetries && err != nil && strings.Contains(err.Error(), l3vniStillBound); i++ {
c.sleep(l3vniRetryDelay)
err = c.configure(s...)
}
return err
}
func (c *Client) runningConfig() (string, error) {
return c.exec("show running-config")
}
func (c *Client) configure(cmds ...string) error {
_, err := c.exec(append([]string{"configure terminal"}, cmds...)...)
return err
}
func (c *Client) save() error {
_, err := c.exec("write memory")
return err
}
func (c *Client) exec(cmds ...string) (string, error) {
args := make([]string, 0, 2*len(cmds))
for _, cmd := range cmds {
args = append(args, "-c", cmd)
}
out, err := c.run(args...)
if err != nil {
return "", fmt.Errorf("vtysh %q: %w: %s", cmds, err, strings.TrimSpace(string(out)))
}
for _, l := range strings.Split(string(out), "\n") {
l = strings.TrimSpace(l)
if strings.HasPrefix(l, "%") && l != appliedWithNotes {
return "", fmt.Errorf("vtysh %q: %s", cmds, l)
}
}
return string(out), nil
}

321
internal/frr/client_test.go Normal file
View file

@ -0,0 +1,321 @@
package frr
import (
"errors"
"net"
"reflect"
"strings"
"testing"
"time"
)
type fakeVtysh struct {
calls [][]string
running []string
fail map[string]string
status map[string]error
failTimes map[string]int
slept int
}
func (f *fakeVtysh) run(args ...string) ([]byte, error) {
var cmds []string
for i := 1; i < len(args); i += 2 {
cmds = append(cmds, args[i])
}
f.calls = append(f.calls, cmds)
last := cmds[len(cmds)-1]
if last == "show running-config" {
if len(f.running) == 0 {
return nil, errors.New("show running-config inattendu")
}
out := f.running[0]
f.running = f.running[1:]
return []byte(out), nil
}
for _, c := range cmds {
out, ok := f.fail[c]
if !ok {
continue
}
if n, limited := f.failTimes[c]; limited {
if n == 0 {
continue
}
f.failTimes[c] = n - 1
}
return []byte(out), f.status[c]
}
return nil, nil
}
func (f *fakeVtysh) client() *Client {
return &Client{run: f.run, sleep: func(time.Duration) { f.slept++ }}
}
func (f *fakeVtysh) sent(cmd string) bool {
for _, c := range f.calls {
for _, x := range c {
if x == cmd {
return true
}
}
}
return false
}
func TestApplyVRFConfiguresThenSaves(t *testing.T) {
f := &fakeVtysh{}
if err := f.client().ApplyVRF(labVRF(t)); err != nil {
t.Fatal(err)
}
want := [][]string{
append([]string{"configure terminal"}, labVRF(t).commands()...),
{"write memory"},
}
if !reflect.DeepEqual(f.calls, want) {
t.Errorf("appels :\n%q\nattendu :\n%q", f.calls, want)
}
}
func TestApplyVRFRefusesAnInvalidVRFWithoutCallingVtysh(t *testing.T) {
f := &fakeVtysh{}
v := labVRF(t)
v.L3VNI = 0
if err := f.client().ApplyVRF(v); err == nil || !strings.Contains(err.Error(), "l3vni 0") {
t.Errorf("erreur %v", err)
}
if len(f.calls) != 0 {
t.Errorf("vtysh appelé : %q", f.calls)
}
}
func TestExecReportsAnErrorPrintedByVtysh(t *testing.T) {
f := &fakeVtysh{fail: map[string]string{"vni 4001": "% Please unconfigure l3vni 4001\n"}}
err := f.client().ApplyVRF(labVRF(t))
if err == nil || !strings.Contains(err.Error(), "% Please unconfigure l3vni 4001") {
t.Errorf("erreur %v", err)
}
if f.sent("write memory") {
t.Error("configuration sauvegardée malgré l'erreur")
}
}
func TestExecReportsANonZeroExit(t *testing.T) {
f := &fakeVtysh{
fail: map[string]string{"write memory": "Building Configuration...\n"},
status: map[string]error{"write memory": errors.New("exit status 1")},
}
err := f.client().ApplyVRF(labVRF(t))
if err == nil || !strings.Contains(err.Error(), "exit status 1") || !strings.Contains(err.Error(), "Building Configuration...") {
t.Errorf("erreur %v", err)
}
}
func TestWithdrawVRFRunsEachStepInOrderThenSaves(t *testing.T) {
f := &fakeVtysh{running: []string{fullRunning, otherOnlyRunning}}
if err := f.client().WithdrawVRF(labVRF(t)); err != nil {
t.Fatal(err)
}
want := [][]string{
{"show running-config"},
{"configure terminal", "router bgp 64600 vrf vrf-a1b2", "address-family ipv4 unicast", "no redistribute kernel"},
{"configure terminal", "vrf vrf-a1b2", "no vni 4001"},
{"configure terminal", "no router bgp 64600 vrf vrf-a1b2"},
{"configure terminal", "no route-map EXPORT-a1b2"},
{"configure terminal", "no ip prefix-list PL-a1b2"},
{"write memory"},
{"show running-config"},
}
if !reflect.DeepEqual(f.calls, want) {
t.Errorf("appels :\n%q\nattendu :\n%q", f.calls, want)
}
}
func TestWithdrawVRFStopsAtTheFirstRefusedStep(t *testing.T) {
f := &fakeVtysh{
running: []string{fullRunning},
fail: map[string]string{"no vni 4001": "% Please unconfigure l3vni 4001\n"},
}
if err := f.client().WithdrawVRF(labVRF(t)); err == nil || !strings.Contains(err.Error(), "Please unconfigure") {
t.Errorf("erreur %v", err)
}
if f.sent("no router bgp 64600 vrf vrf-a1b2") {
t.Error("instance BGP supprimée après un refus de l'étape précédente")
}
}
func TestWithdrawVRFFailsWhenFRRKeptTheConfiguration(t *testing.T) {
f := &fakeVtysh{running: []string{fullRunning, fullRunning}}
err := f.client().WithdrawVRF(labVRF(t))
if err == nil || !strings.Contains(err.Error(), "configuration still present after teardown") || !strings.Contains(err.Error(), "no router bgp 64600 vrf vrf-a1b2") {
t.Errorf("erreur %v", err)
}
}
func TestRemoveVRFDeletesTheVRFAndChecksNothingIsLeft(t *testing.T) {
gone := "vrf vrf-a1b2c\n vni 4002\nexit-vrf\n"
f := &fakeVtysh{running: []string{otherOnlyRunning, gone, gone}}
if err := f.client().RemoveVRF(labVRF(t)); err != nil {
t.Fatal(err)
}
if !f.sent("no vrf vrf-a1b2") {
t.Errorf("appels : %q", f.calls)
}
}
func TestRemoveVRFFailsWhenRoutingConfigurationIsStillThere(t *testing.T) {
f := &fakeVtysh{running: []string{otherOnlyRunning, "", fullRunning}}
err := f.client().RemoveVRF(labVRF(t))
if err == nil || !strings.Contains(err.Error(), "configuration still present after teardown") {
t.Errorf("erreur %v", err)
}
}
func TestTeardownNeedsOnlyTheID(t *testing.T) {
f := &fakeVtysh{running: []string{"", ""}}
if err := f.client().WithdrawVRF(VRF{ID: "a1b2"}); err != nil {
t.Errorf("démontage sans asn refusé : %v", err)
}
f = &fakeVtysh{}
if err := f.client().WithdrawVRF(VRF{ASN: 64600}); err == nil || len(f.calls) != 0 {
t.Errorf("démontage sans id : erreur %v, appels %q", err, f.calls)
}
}
const baseRunning = `frr version 10.7.1
router bgp 64600
bgp router-id 192.168.14.13
neighbor fabric peer-group
neighbor fabric remote-as 64600
neighbor 10.255.255.1 peer-group fabric
neighbor 10.255.255.9 peer-group fabric
neighbor 10.0.0.5 peer-group monitoring
!
address-family l2vpn evpn
neighbor fabric activate
advertise-all-vni
exit-address-family
exit
!
router bgp 64600 vrf vrf-a1b2
neighbor 10.255.255.7 peer-group fabric
exit
`
func labBase() Base {
return Base{ASN: 64600, RouterID: net.ParseIP("192.168.14.13"), RouteReflectors: []net.IP{net.ParseIP("10.255.255.1")}}
}
func TestApplyBaseOnAFreshFRRConfiguresThenSaves(t *testing.T) {
f := &fakeVtysh{running: []string{""}}
if err := f.client().ApplyBase(labBase()); err != nil {
t.Fatal(err)
}
want := [][]string{
{"show running-config"},
append([]string{"configure terminal"}, labBase().commands()...),
{"write memory"},
}
if !reflect.DeepEqual(f.calls, want) {
t.Errorf("appels :\n%q\nattendu :\n%q", f.calls, want)
}
}
func TestApplyBaseRemovesReflectorsNoLongerConfiguredAfterAddingTheNewOnes(t *testing.T) {
f := &fakeVtysh{running: []string{baseRunning}}
if err := f.client().ApplyBase(labBase()); err != nil {
t.Fatal(err)
}
want := [][]string{
{"show running-config"},
append([]string{"configure terminal"}, labBase().commands()...),
{"configure terminal", "router bgp 64600", "no neighbor 10.255.255.9", "exit"},
{"write memory"},
}
if !reflect.DeepEqual(f.calls, want) {
t.Errorf("appels :\n%q\nattendu :\n%q", f.calls, want)
}
}
func TestApplyBaseRefusesToChangeTheASN(t *testing.T) {
f := &fakeVtysh{running: []string{baseRunning}}
b := labBase()
b.ASN = 64601
err := f.client().ApplyBase(b)
if err == nil || !strings.Contains(err.Error(), "bgp already runs as AS 64600, not 64601") {
t.Errorf("erreur %v", err)
}
if len(f.calls) != 1 {
t.Errorf("appels après le refus : %q", f.calls)
}
}
func TestApplyBaseStopsWhenTheRunningConfigIsUnreadable(t *testing.T) {
f := &fakeVtysh{}
if err := f.client().ApplyBase(labBase()); err == nil {
t.Fatal("aucune erreur")
}
if f.sent("write memory") || f.sent("router bgp 64600") {
t.Errorf("appels : %q", f.calls)
}
}
func TestExecAcceptsAConfigurationAppliedWithNotes(t *testing.T) {
f := &fakeVtysh{fail: map[string]string{"vni 4001": "% Configuration applied with notes:\nNo changes found to be committed!\n"}}
if err := f.client().ApplyVRF(labVRF(t)); err != nil {
t.Errorf("remarques prises pour une erreur : %v", err)
}
}
func TestExecStillReportsOtherPercentLines(t *testing.T) {
f := &fakeVtysh{fail: map[string]string{"vni 4001": "% Configuration applied with notes:\n% Unknown command: vni 4001\n"}}
if err := f.client().ApplyVRF(labVRF(t)); err == nil || !strings.Contains(err.Error(), "% Unknown command") {
t.Errorf("erreur %v", err)
}
}
func TestWithdrawVRFWaitsForBGPToReleaseTheL3VNI(t *testing.T) {
f := &fakeVtysh{
running: []string{fullRunning, otherOnlyRunning},
fail: map[string]string{"no router bgp 64600 vrf vrf-a1b2": "% Please unconfigure l3vni 4001\n"},
status: map[string]error{"no router bgp 64600 vrf vrf-a1b2": errors.New("exit status 1")},
failTimes: map[string]int{"no router bgp 64600 vrf vrf-a1b2": 3},
}
if err := f.client().WithdrawVRF(labVRF(t)); err != nil {
t.Fatalf("refus transitoire non rattrapé : %v", err)
}
if f.slept != 3 {
t.Errorf("%d attentes, attendu 3", f.slept)
}
if !f.sent("no route-map EXPORT-a1b2") {
t.Errorf("démontage interrompu : %q", f.calls)
}
}
func TestWithdrawVRFGivesUpOnAPersistentL3VNIRefusal(t *testing.T) {
f := &fakeVtysh{
running: []string{fullRunning},
fail: map[string]string{"no router bgp 64600 vrf vrf-a1b2": "% Please unconfigure l3vni 4001\n"},
}
err := f.client().WithdrawVRF(labVRF(t))
if err == nil || !strings.Contains(err.Error(), "Please unconfigure l3vni 4001") {
t.Fatalf("erreur %v", err)
}
if f.slept != l3vniRetries {
t.Errorf("%d attentes, attendu %d", f.slept, l3vniRetries)
}
if f.sent("no route-map EXPORT-a1b2") {
t.Error("étape suivante exécutée après l'abandon")
}
}
func TestOtherTeardownErrorsAreNotRetried(t *testing.T) {
f := &fakeVtysh{
running: []string{fullRunning},
fail: map[string]string{"no router bgp 64600 vrf vrf-a1b2": "% Unknown command\n"},
}
if err := f.client().WithdrawVRF(labVRF(t)); err == nil || f.slept != 0 {
t.Errorf("erreur %v, %d attentes", err, f.slept)
}
}

155
internal/frr/config.go Normal file
View file

@ -0,0 +1,155 @@
package frr
import (
"fmt"
"net"
"strings"
)
const MaxL3VNI = 1<<16 - 1
type Base struct {
ASN uint32
RouterID net.IP
RouteReflectors []net.IP
}
type VRF struct {
ASN uint32
ID string
L3VNI uint32
VTEP net.IP
Supernet *net.IPNet
}
func (b Base) validate() error {
if b.ASN == 0 {
return fmt.Errorf("frr: asn must not be 0")
}
if b.RouterID.To4() == nil {
return fmt.Errorf("frr: router-id %v is not an IPv4 address", b.RouterID)
}
if len(b.RouteReflectors) == 0 {
return fmt.Errorf("frr: at least one route reflector is required")
}
for _, rr := range b.RouteReflectors {
if rr.To4() == nil {
return fmt.Errorf("frr: route reflector %v is not an IPv4 address", rr)
}
}
return nil
}
func (b Base) commands() []string {
cmds := []string{
fmt.Sprintf("router bgp %d", b.ASN),
fmt.Sprintf("bgp router-id %s", b.RouterID),
"no bgp default ipv4-unicast",
"neighbor fabric peer-group",
fmt.Sprintf("neighbor fabric remote-as %d", b.ASN),
"neighbor fabric capability extended-nexthop",
}
for _, rr := range b.RouteReflectors {
cmds = append(cmds, fmt.Sprintf("neighbor %s peer-group fabric", rr))
}
return append(cmds,
"address-family l2vpn evpn",
"neighbor fabric activate",
"advertise-all-vni",
"exit-address-family",
"exit",
)
}
func (b Base) staleReflectors(running string) ([]string, error) {
want := make(map[string]bool, len(b.RouteReflectors))
for _, rr := range b.RouteReflectors {
want[rr.String()] = true
}
var stale []string
in := false
for _, l := range strings.Split(running, "\n") {
l = strings.TrimRight(l, " \r")
f := strings.Fields(l)
switch {
case len(f) == 3 && f[0] == "router" && f[1] == "bgp":
if f[2] != fmt.Sprint(b.ASN) {
return nil, fmt.Errorf("frr: bgp already runs as AS %s, not %d: changing the asn requires removing that instance by hand", f[2], b.ASN)
}
in = true
case in && l == "exit":
in = false
case in && len(f) == 4 && f[0] == "neighbor" && f[2] == "peer-group" && f[3] == "fabric" && !want[f[1]]:
stale = append(stale, f[1])
}
}
return stale, nil
}
func (v VRF) Name() string {
return "vrf-" + v.ID
}
func (v VRF) prefixList() string {
return "PL-" + v.ID
}
func (v VRF) routeMap() string {
return "EXPORT-" + v.ID
}
func (v VRF) bgpInstance() string {
return fmt.Sprintf("router bgp %d vrf %s", v.ASN, v.Name())
}
func (v VRF) validateName() error {
if v.ASN == 0 {
return fmt.Errorf("frr: asn must not be 0")
}
if v.ID == "" {
return fmt.Errorf("frr: vrf id must not be empty")
}
return nil
}
func (v VRF) validate() error {
if err := v.validateName(); err != nil {
return err
}
if v.L3VNI == 0 || v.L3VNI > MaxL3VNI {
return fmt.Errorf("frr: l3vni %d out of range 1-%d: the route distinguisher <vtep>:<l3vni> holds 16 bits", v.L3VNI, MaxL3VNI)
}
if v.VTEP.To4() == nil {
return fmt.Errorf("frr: vtep %v is not an IPv4 address", v.VTEP)
}
if v.Supernet == nil || v.Supernet.IP.To4() == nil {
return fmt.Errorf("frr: supernet %v is not an IPv4 prefix", v.Supernet)
}
return nil
}
func (v VRF) commands() []string {
return []string{
fmt.Sprintf("ip prefix-list %s seq 10 permit %s le 32", v.prefixList(), v.Supernet),
fmt.Sprintf("route-map %s permit 10", v.routeMap()),
fmt.Sprintf("match ip address prefix-list %s", v.prefixList()),
"exit",
fmt.Sprintf("route-map %s deny 20", v.routeMap()),
"exit",
fmt.Sprintf("vrf %s", v.Name()),
fmt.Sprintf("vni %d", v.L3VNI),
"exit-vrf",
v.bgpInstance(),
fmt.Sprintf("bgp router-id %s", v.VTEP),
"no bgp default ipv4-unicast",
"address-family ipv4 unicast",
fmt.Sprintf("redistribute kernel route-map %s", v.routeMap()),
"exit-address-family",
"address-family l2vpn evpn",
fmt.Sprintf("rd %s:%d", v.VTEP, v.L3VNI),
fmt.Sprintf("route-target both %d:%d", v.ASN, v.L3VNI),
"advertise ipv4 unicast",
"exit-address-family",
"exit",
}
}

143
internal/frr/config_test.go Normal file
View file

@ -0,0 +1,143 @@
package frr
import (
"net"
"reflect"
"strings"
"testing"
)
func mustCIDR(t *testing.T, s string) *net.IPNet {
t.Helper()
_, n, err := net.ParseCIDR(s)
if err != nil {
t.Fatal(err)
}
return n
}
func labVRF(t *testing.T) VRF {
return VRF{
ASN: 64600,
ID: "a1b2",
L3VNI: 4001,
VTEP: net.ParseIP("192.168.14.11"),
Supernet: mustCIDR(t, "10.10.0.0/16"),
}
}
func TestBaseCommands(t *testing.T) {
b := Base{
ASN: 64600,
RouterID: net.ParseIP("192.168.14.13"),
RouteReflectors: []net.IP{net.ParseIP("10.255.255.1"), net.ParseIP("10.255.255.2")},
}
want := []string{
"router bgp 64600",
"bgp router-id 192.168.14.13",
"no bgp default ipv4-unicast",
"neighbor fabric peer-group",
"neighbor fabric remote-as 64600",
"neighbor fabric capability extended-nexthop",
"neighbor 10.255.255.1 peer-group fabric",
"neighbor 10.255.255.2 peer-group fabric",
"address-family l2vpn evpn",
"neighbor fabric activate",
"advertise-all-vni",
"exit-address-family",
"exit",
}
if got := b.commands(); !reflect.DeepEqual(got, want) {
t.Errorf("commandes de base :\n%s\nattendu :\n%s", strings.Join(got, "\n"), strings.Join(want, "\n"))
}
}
func TestVRFCommands(t *testing.T) {
want := []string{
"ip prefix-list PL-a1b2 seq 10 permit 10.10.0.0/16 le 32",
"route-map EXPORT-a1b2 permit 10",
"match ip address prefix-list PL-a1b2",
"exit",
"route-map EXPORT-a1b2 deny 20",
"exit",
"vrf vrf-a1b2",
"vni 4001",
"exit-vrf",
"router bgp 64600 vrf vrf-a1b2",
"bgp router-id 192.168.14.11",
"no bgp default ipv4-unicast",
"address-family ipv4 unicast",
"redistribute kernel route-map EXPORT-a1b2",
"exit-address-family",
"address-family l2vpn evpn",
"rd 192.168.14.11:4001",
"route-target both 64600:4001",
"advertise ipv4 unicast",
"exit-address-family",
"exit",
}
if got := labVRF(t).commands(); !reflect.DeepEqual(got, want) {
t.Errorf("commandes de VRF :\n%s\nattendu :\n%s", strings.Join(got, "\n"), strings.Join(want, "\n"))
}
}
func TestBaseValidateRejects(t *testing.T) {
valid := func() Base {
return Base{ASN: 64600, RouterID: net.ParseIP("192.168.14.13"), RouteReflectors: []net.IP{net.ParseIP("10.255.255.1")}}
}
if err := valid().validate(); err != nil {
t.Fatalf("base valide refusée : %v", err)
}
cases := map[string]struct {
mutate func(*Base)
msg string
}{
"asn nul": {func(b *Base) { b.ASN = 0 }, "asn must not be 0"},
"router-id absent": {func(b *Base) { b.RouterID = nil }, "router-id <nil> is not an IPv4 address"},
"router-id IPv6": {func(b *Base) { b.RouterID = net.ParseIP("fd00::1") }, "router-id fd00::1 is not an IPv4 address"},
"aucun RR": {func(b *Base) { b.RouteReflectors = nil }, "at least one route reflector is required"},
"RR IPv6": {func(b *Base) { b.RouteReflectors = append(b.RouteReflectors, net.ParseIP("fd00::2")) }, "route reflector fd00::2 is not an IPv4 address"},
}
for name, c := range cases {
b := valid()
c.mutate(&b)
if err := b.validate(); err == nil || !strings.Contains(err.Error(), c.msg) {
t.Errorf("%s : erreur %v, « %s » attendu", name, err, c.msg)
}
}
}
func TestVRFValidateRejects(t *testing.T) {
if err := labVRF(t).validate(); err != nil {
t.Fatalf("VRF valide refusée : %v", err)
}
cases := map[string]struct {
mutate func(*VRF)
msg string
}{
"asn nul": {func(v *VRF) { v.ASN = 0 }, "asn must not be 0"},
"id vide": {func(v *VRF) { v.ID = "" }, "vrf id must not be empty"},
"l3vni nul": {func(v *VRF) { v.L3VNI = 0 }, "l3vni 0 out of range 1-65535"},
"l3vni sur 17 bits": {func(v *VRF) { v.L3VNI = 65536 }, "l3vni 65536 out of range 1-65535"},
"l3vni sur 24 bits": {func(v *VRF) { v.L3VNI = 16777215 }, "l3vni 16777215 out of range 1-65535"},
"vtep absent": {func(v *VRF) { v.VTEP = nil }, "vtep <nil> is not an IPv4 address"},
"vtep IPv6": {func(v *VRF) { v.VTEP = net.ParseIP("fd00::1") }, "vtep fd00::1 is not an IPv4 address"},
"supernet absent": {func(v *VRF) { v.Supernet = nil }, "supernet <nil> is not an IPv4 prefix"},
"supernet IPv6": {func(v *VRF) { v.Supernet = mustCIDR(t, "fd00::/48") }, "supernet fd00::/48 is not an IPv4 prefix"},
}
for name, c := range cases {
v := labVRF(t)
c.mutate(&v)
if err := v.validate(); err == nil || !strings.Contains(err.Error(), c.msg) {
t.Errorf("%s : erreur %v, « %s » attendu", name, err, c.msg)
}
}
}
func TestVRFAcceptsTheLargest16BitVNI(t *testing.T) {
v := labVRF(t)
v.L3VNI = 65535
if err := v.validate(); err != nil {
t.Errorf("l3vni 65535 refusée : %v", err)
}
}

49
internal/frr/status.go Normal file
View file

@ -0,0 +1,49 @@
package frr
import (
"fmt"
"net"
"strings"
)
type VNIState struct {
Type string
State string
RouterMAC string
}
func (c *Client) NeighborEstablished(peer net.IP) (bool, error) {
out, err := c.exec("show bgp neighbors " + peer.String())
if err != nil {
return false, err
}
return strings.Contains(out, "BGP state = Established"), nil
}
func (c *Client) VNI(vni uint32) (VNIState, error) {
out, err := c.exec(fmt.Sprintf("show evpn vni %d", vni))
if err != nil {
return VNIState{}, err
}
return parseVNI(out), nil
}
func parseVNI(out string) VNIState {
var s VNIState
for _, l := range strings.Split(out, "\n") {
key, value, ok := strings.Cut(strings.TrimSpace(l), ": ")
if !ok {
continue
}
value = strings.TrimSpace(value)
switch strings.ToLower(key) {
case "type":
s.Type = value
case "state":
s.State = value
case "router mac":
s.RouterMAC = strings.ToLower(value)
}
}
return s
}

View file

@ -0,0 +1,50 @@
package frr
import (
"net"
"strings"
"testing"
)
const vniOutput = `VNI: 2700
Type: L3
Tenant VRF: vrf-s7
Vxlan-Intf: vxl3-s7
SVI-If: brl3-s7
State: Up
VNI Filter: none
System MAC: 02:02:c0:a8:0e:aa
Router MAC: 02:02:C0:A8:0E:0B
L2 VNIs:
`
func TestVNIReadsTypeStateAndRouterMAC(t *testing.T) {
f := &fakeVtysh{fail: map[string]string{"show evpn vni 2700": vniOutput}}
s, err := f.client().VNI(2700)
if err != nil {
t.Fatal(err)
}
want := VNIState{Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:0b"}
if s != want {
t.Errorf("VNI = %+v, attendu %+v", s, want)
}
}
func TestVNIReportsAnUnknownVNI(t *testing.T) {
f := &fakeVtysh{fail: map[string]string{"show evpn vni 9": "% VNI 9 does not exist\n"}}
if _, err := f.client().VNI(9); err == nil || !strings.Contains(err.Error(), "does not exist") {
t.Errorf("erreur %v", err)
}
}
func TestNeighborEstablished(t *testing.T) {
rr := net.ParseIP("10.255.255.1")
f := &fakeVtysh{fail: map[string]string{"show bgp neighbors 10.255.255.1": "BGP neighbor is 10.255.255.1, remote AS 64600, local AS 64600, internal link\n BGP version 4, remote router ID 10.255.255.1\n BGP state = Established, up for 00:10:02\n"}}
if up, err := f.client().NeighborEstablished(rr); err != nil || !up {
t.Errorf("établie : %v, %v", up, err)
}
f = &fakeVtysh{fail: map[string]string{"show bgp neighbors 10.255.255.1": "BGP neighbor is 10.255.255.1\n BGP state = Active\n"}}
if up, err := f.client().NeighborEstablished(rr); err != nil || up {
t.Errorf("active : %v, %v", up, err)
}
}

99
internal/frr/teardown.go Normal file
View file

@ -0,0 +1,99 @@
package frr
import (
"fmt"
"strconv"
"strings"
)
type step []string
func routingTeardown(v VRF, running string) []step {
lines := strings.Split(running, "\n")
instance := vrfInstance(lines, v.Name())
bgp := instance != ""
var steps []step
if bgp {
steps = append(steps, step{instance, "address-family ipv4 unicast", "no redistribute kernel"})
}
if vni := vrfVNI(lines, v.Name()); vni != "" {
steps = append(steps, step{"vrf " + v.Name(), "no vni " + vni})
}
if bgp {
steps = append(steps, step{"no " + instance})
}
if hasPrefix(lines, "route-map "+v.routeMap()+" ") {
steps = append(steps, step{"no route-map " + v.routeMap()})
}
if hasPrefix(lines, "ip prefix-list "+v.prefixList()+" ") {
steps = append(steps, step{"no ip prefix-list " + v.prefixList()})
}
return steps
}
func vrfTeardown(v VRF, running string) []step {
if hasLine(strings.Split(running, "\n"), "vrf "+v.Name()) {
return []step{{"no vrf " + v.Name()}}
}
return nil
}
func vrfInstance(lines []string, name string) string {
for _, l := range lines {
f := strings.Fields(l)
if len(f) != 5 || f[0] != "router" || f[1] != "bgp" || f[3] != "vrf" || f[4] != name {
continue
}
if _, err := strconv.ParseUint(f[2], 10, 32); err == nil {
return strings.Join(f, " ")
}
}
return ""
}
func hasLine(lines []string, want string) bool {
for _, l := range lines {
if strings.TrimRight(l, " \r") == want {
return true
}
}
return false
}
func hasPrefix(lines []string, prefix string) bool {
for _, l := range lines {
if strings.HasPrefix(l, prefix) {
return true
}
}
return false
}
func vrfVNI(lines []string, name string) string {
in := false
for _, l := range lines {
l = strings.TrimRight(l, " \r")
switch {
case l == "vrf "+name:
in = true
case in && l == "exit-vrf":
return ""
case in:
if f := strings.Fields(l); len(f) >= 2 && f[0] == "vni" {
return f[1]
}
}
}
return ""
}
func remaining(steps []step) error {
if len(steps) == 0 {
return nil
}
var parts []string
for _, s := range steps {
parts = append(parts, strings.Join(s, " / "))
}
return fmt.Errorf("configuration still present after teardown: %s", strings.Join(parts, "; "))
}

View file

@ -0,0 +1,159 @@
package frr
import (
"reflect"
"testing"
)
const fullRunning = `frr version 10.7.1
frr defaults traditional
hostname hv1
!
vrf vrf-a1b2
vni 4001
exit-vrf
!
vrf vrf-a1b2c
vni 4002
exit-vrf
!
router bgp 64600
bgp router-id 192.168.14.11
no bgp default ipv4-unicast
neighbor fabric peer-group
neighbor fabric remote-as 64600
neighbor 10.255.255.1 peer-group fabric
!
address-family l2vpn evpn
neighbor fabric activate
advertise-all-vni
exit-address-family
exit
!
router bgp 64600 vrf vrf-a1b2
bgp router-id 192.168.14.11
no bgp default ipv4-unicast
!
address-family ipv4 unicast
redistribute kernel route-map EXPORT-a1b2
exit-address-family
!
address-family l2vpn evpn
advertise ipv4 unicast
rd 192.168.14.11:4001
route-target import 64600:4001
route-target export 64600:4001
exit-address-family
exit
!
router bgp 64600 vrf vrf-a1b2c
bgp router-id 192.168.14.11
exit
!
ip prefix-list PL-a1b2 seq 10 permit 10.10.0.0/16 le 32
ip prefix-list PL-a1b2c seq 10 permit 10.20.0.0/16 le 32
!
route-map EXPORT-a1b2 permit 10
match ip address prefix-list PL-a1b2
exit
!
route-map EXPORT-a1b2 deny 20
exit
!
route-map EXPORT-a1b2c permit 10
exit
!
end
`
const otherOnlyRunning = `vrf vrf-a1b2
exit-vrf
!
vrf vrf-a1b2c
vni 4002
exit-vrf
!
router bgp 64600 vrf vrf-a1b2c
exit
!
ip prefix-list PL-a1b2c seq 10 permit 10.20.0.0/16 le 32
!
route-map EXPORT-a1b2c permit 10
exit
!
end
`
func TestRoutingTeardownFollowsTheOrderFRRRequires(t *testing.T) {
want := []step{
{"router bgp 64600 vrf vrf-a1b2", "address-family ipv4 unicast", "no redistribute kernel"},
{"vrf vrf-a1b2", "no vni 4001"},
{"no router bgp 64600 vrf vrf-a1b2"},
{"no route-map EXPORT-a1b2"},
{"no ip prefix-list PL-a1b2"},
}
if got := routingTeardown(labVRF(t), fullRunning); !reflect.DeepEqual(got, want) {
t.Errorf("démontage :\n%q\nattendu :\n%q", got, want)
}
}
func TestRoutingTeardownTakesTheASNOfTheInstanceFromFRR(t *testing.T) {
want := []step{
{"router bgp 64600 vrf vrf-a1b2", "address-family ipv4 unicast", "no redistribute kernel"},
{"vrf vrf-a1b2", "no vni 4001"},
{"no router bgp 64600 vrf vrf-a1b2"},
{"no route-map EXPORT-a1b2"},
{"no ip prefix-list PL-a1b2"},
}
for _, asn := range []uint32{0, 64601} {
v := labVRF(t)
v.ASN = asn
if got := routingTeardown(v, fullRunning); !reflect.DeepEqual(got, want) {
t.Errorf("asn %d :\n%q\nattendu :\n%q", asn, got, want)
}
}
}
func TestRoutingTeardownIgnoresAVRFWhoseNameExtendsOurs(t *testing.T) {
if got := routingTeardown(labVRF(t), otherOnlyRunning); got != nil {
t.Errorf("étapes visant vrf-a1b2c : %q", got)
}
}
func TestRoutingTeardownUsesTheVNIFoundInFRR(t *testing.T) {
v := labVRF(t)
v.L3VNI = 9999
running := "vrf vrf-a1b2\n vni 4001\nexit-vrf\n"
want := []step{{"vrf vrf-a1b2", "no vni 4001"}}
if got := routingTeardown(v, running); !reflect.DeepEqual(got, want) {
t.Errorf("démontage : %q, %q attendu", got, want)
}
}
func TestRoutingTeardownSkipsWhatIsAbsent(t *testing.T) {
running := "vrf vrf-a1b2\n vni 4001\nexit-vrf\n!\nip prefix-list PL-a1b2 seq 10 permit 10.10.0.0/16 le 32\n"
want := []step{
{"vrf vrf-a1b2", "no vni 4001"},
{"no ip prefix-list PL-a1b2"},
}
if got := routingTeardown(labVRF(t), running); !reflect.DeepEqual(got, want) {
t.Errorf("démontage :\n%q\nattendu :\n%q", got, want)
}
}
func TestRoutingTeardownDoesNotReadAVNIOutsideTheVRFBlock(t *testing.T) {
running := "vrf vrf-a1b2\nexit-vrf\n!\nvrf vrf-a1b2c\n vni 4002\nexit-vrf\n"
if got := routingTeardown(labVRF(t), running); got != nil {
t.Errorf("étapes : %q", got)
}
}
func TestVRFTeardown(t *testing.T) {
want := []step{{"no vrf vrf-a1b2"}}
if got := vrfTeardown(labVRF(t), otherOnlyRunning); !reflect.DeepEqual(got, want) {
t.Errorf("démontage : %q, %q attendu", got, want)
}
if got := vrfTeardown(labVRF(t), "vrf vrf-a1b2c\nexit-vrf\n"); got != nil {
t.Errorf("étapes visant vrf-a1b2c : %q", got)
}
}

94
internal/l3vni/host.go Normal file
View file

@ -0,0 +1,94 @@
package l3vni
import (
"net"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/netns"
"git.g3e.fr/syonad/two/internal/sysctl"
)
type host interface {
VTEPAddress(iface string) (net.IP, error)
Sysctl(ns, key, value string) error
CreateVRF(name string, table uint32) error
CreateBridge(name string, mtu int, mac net.HardwareAddr) error
SetMaster(iface, master string) error
CreateVxlan(name string, vni int, iface string, mtu int) error
CreateVeth(hostIf, nsIf, ns string, mtu int) error
AddrAdd(ns, iface string, prefix *net.IPNet) error
LinkUp(ns, iface string) error
RouteVia(ns string, dst *net.IPNet, gw net.IP, iface string) error
DeleteLink(name string) error
TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error
TableRouteDel(table uint32, dst *net.IPNet) error
ApplyVRF(v frr.VRF) error
WithdrawVRF(v frr.VRF) error
RemoveVRF(v frr.VRF) error
}
type system struct {
frr *frr.Client
}
func newSystem() system {
return system{frr: frr.NewClient()}
}
func in(ns string, fn func() error) error {
if ns == "" {
return fn()
}
return netns.Call(ns, fn)
}
func (system) VTEPAddress(iface string) (net.IP, error) { return netif.VTEPAddress(iface) }
func (system) Sysctl(ns, key, value string) error {
return in(ns, func() error { return sysctl.Set(key, value) })
}
func (system) CreateVRF(name string, table uint32) error { return netif.CreateVRF(name, table) }
func (system) CreateBridge(name string, mtu int, mac net.HardwareAddr) error {
return netif.CreateBridge(name, mtu, mac)
}
func (system) SetMaster(iface, master string) error { return netif.BridgeSetMaster(iface, master) }
func (system) CreateVxlan(name string, vni int, iface string, mtu int) error {
return netif.CreateVxlan(name, vni, iface, mtu)
}
func (system) CreateVeth(hostIf, nsIf, ns string, mtu int) error {
return netif.CreateVethToNetns(hostIf, nsIf, "/var/run/netns/"+ns, mtu)
}
func (system) AddrAdd(ns, iface string, prefix *net.IPNet) error {
return in(ns, func() error { return netif.AddrAddPrefix(iface, prefix) })
}
func (system) LinkUp(ns, iface string) error {
return in(ns, func() error { return netif.LinkSetUp(iface) })
}
func (system) RouteVia(ns string, dst *net.IPNet, gw net.IP, iface string) error {
return in(ns, func() error { return netif.RouteReplaceVia(0, dst, gw, iface) })
}
func (system) DeleteLink(name string) error { return netif.DeleteLinkIfExists(name) }
func (system) TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error {
return netif.RouteReplaceVia(int(table), dst, gw, iface)
}
func (system) TableRouteDel(table uint32, dst *net.IPNet) error {
return netif.RouteDelIfExists(int(table), dst)
}
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) }
func (s system) RemoveVRF(v frr.VRF) error { return s.frr.RemoveVRF(v) }

177
internal/l3vni/l3.go Normal file
View file

@ -0,0 +1,177 @@
package l3vni
import (
"errors"
"fmt"
"net"
"strconv"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/pkg/db/kv"
"github.com/dgraph-io/badger/v4"
)
const l3MTU = 1500
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)}
)
type l3VPC struct {
netns string
id string
vni uint32
supernet *net.IPNet
}
func loadL3(db *badger.DB, name, id string) (l3VPC, bool, error) {
raw, err := kv.GetFromDB(db, "vpc/"+name+"/l3vni")
if errors.Is(err, badger.ErrKeyNotFound) {
return l3VPC{}, false, nil
}
if err != nil {
return l3VPC{}, false, fmt.Errorf("vpc %q: reading l3vni: %w", name, err)
}
vni, err := strconv.ParseUint(raw, 10, 32)
if err != nil {
return l3VPC{}, false, fmt.Errorf("vpc %q: invalid l3vni %q", name, raw)
}
if err := Valid(uint32(vni)); err != nil {
return l3VPC{}, false, fmt.Errorf("vpc %q: %w", name, err)
}
cidr, err := kv.GetFromDB(db, "vpc/"+name+"/cidr")
if err != nil {
return l3VPC{}, false, fmt.Errorf("vpc %q: no cidr: %w", name, err)
}
_, supernet, err := net.ParseCIDR(cidr)
if err != nil {
return l3VPC{}, false, fmt.Errorf("vpc %q: invalid cidr %q: %w", name, cidr, err)
}
return l3VPC{netns: name, id: id, vni: uint32(vni), supernet: supernet}, true, nil
}
func (v l3VPC) vrf() string { return "vrf-" + v.id }
func (v l3VPC) bridge() string { return "brl3-" + v.id }
func (v l3VPC) vxlan() string { return "vxl3-" + v.id }
func (v l3VPC) vethHost() string { return "l3-" + v.id + "-o" }
func (v l3VPC) vethNetns() string { return "l3-" + v.id + "-i" }
func bgpASN(cfg *configuration.Config) (uint32, error) {
if cfg == nil || !cfg.BGP.Enabled() {
return 0, fmt.Errorf("the vpc has an l3vni but the agent configuration has no bgp section")
}
return cfg.BGP.ASN, nil
}
func createL3(h host, cfg *configuration.Config, v l3VPC) error {
asn, err := bgpASN(cfg)
if err != nil {
return err
}
vtep, err := h.VTEPAddress(cfg.DefaultInterface)
if err != nil {
return fmt.Errorf("vtep: %w", err)
}
rmac, err := RouterMAC(vtep)
if err != nil {
return err
}
steps := []struct {
what string
run func() error
}{
{"create " + v.vrf(), func() error { return h.CreateVRF(v.vrf(), v.vni) }},
{"create " + v.bridge(), func() error { return h.CreateBridge(v.bridge(), l3MTU, 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, l3MTU) }},
{"attach " + v.vxlan(), func() error { return h.SetMaster(v.vxlan(), v.bridge()) }},
{"set up " + v.vxlan(), func() error { return h.LinkUp("", v.vxlan()) }},
{"create " + v.vethHost(), func() error { return h.CreateVeth(v.vethHost(), v.vethNetns(), v.netns, l3MTU) }},
{"attach " + v.vethHost(), func() error { return h.SetMaster(v.vethHost(), v.vrf()) }},
{"address " + v.vethHost(), func() error { return h.AddrAdd("", v.vethHost(), transitHost) }},
{"set up " + v.vethHost(), func() error { return h.LinkUp("", v.vethHost()) }},
{"forwarding on " + v.bridge(), func() error { return h.Sysctl("", "net.ipv4.conf."+v.bridge()+".forwarding", "1") }},
{"forwarding on " + v.vethHost(), func() error { return h.Sysctl("", "net.ipv4.conf."+v.vethHost()+".forwarding", "1") }},
{"address " + v.vethNetns(), func() error { return h.AddrAdd(v.netns, v.vethNetns(), transitNetns) }},
{"set up " + v.vethNetns(), func() error { return h.LinkUp(v.netns, v.vethNetns()) }},
{"forwarding in " + v.netns, func() error { return h.Sysctl(v.netns, "net.ipv4.ip_forward", "1") }},
{"route " + v.supernet.String() + " in " + v.netns, func() error {
return h.RouteVia(v.netns, v.supernet, transitHost.IP, v.vethNetns())
}},
{"frr " + v.vrf(), func() error {
return h.ApplyVRF(frr.VRF{ASN: asn, ID: v.id, L3VNI: v.vni, VTEP: vtep, Supernet: v.supernet})
}},
}
for _, s := range steps {
if err := s.run(); err != nil {
return fmt.Errorf("l3vni %d: %s: %w", v.vni, s.what, err)
}
}
return nil
}
func deleteL3(h host, v l3VPC) error {
frrVRF := frr.VRF{ID: v.id}
if err := h.WithdrawVRF(frrVRF); err != nil {
return fmt.Errorf("l3vni %d: withdraw frr: %w", v.vni, err)
}
for _, link := range []string{v.vethHost(), v.vxlan(), v.bridge(), v.vrf()} {
if err := h.DeleteLink(link); err != nil {
return fmt.Errorf("l3vni %d: delete %s: %w", v.vni, link, err)
}
}
if err := h.RemoveVRF(frrVRF); err != nil {
return fmt.Errorf("l3vni %d: remove frr vrf: %w", v.vni, err)
}
return nil
}
func Create(db *badger.DB, vpcName string, cfg *configuration.Config) error {
v, ok, err := loadRouted(db, vpcName)
if err != nil || !ok {
return err
}
return createL3(newSystem(), cfg, v)
}
func Delete(db *badger.DB, vpcName string) error {
v, ok, err := loadRouted(db, vpcName)
if err != nil || !ok {
return err
}
return deleteL3(newSystem(), v)
}
type Routing struct {
VNI uint32
Supernet *net.IPNet
VRF string
Bridge string
Vxlan string
VethHost string
VethNetns string
}
func LoadRouting(db *badger.DB, vpcName string) (Routing, bool, error) {
v, ok, err := loadRouted(db, vpcName)
if err != nil || !ok {
return Routing{}, ok, err
}
return Routing{
VNI: v.vni,
Supernet: v.supernet,
VRF: v.vrf(),
Bridge: v.bridge(),
Vxlan: v.vxlan(),
VethHost: v.vethHost(),
VethNetns: v.vethNetns(),
}, true, nil
}
func RouterMAC(vtep net.IP) (net.HardwareAddr, error) {
return netif.HostMAC(netif.RoleRouter, vtep)
}

260
internal/l3vni/l3_test.go Normal file
View file

@ -0,0 +1,260 @@
package l3vni
import (
"errors"
"fmt"
"net"
"reflect"
"strings"
"testing"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/pkg/db/kv"
)
type fakeHost struct {
calls []string
fail map[string]error
}
func (f *fakeHost) record(call string) error {
f.calls = append(f.calls, call)
for prefix, err := range f.fail {
if strings.HasPrefix(call, prefix) {
return err
}
}
return nil
}
func (f *fakeHost) VTEPAddress(iface string) (net.IP, error) {
if err := f.record("vtep " + iface); err != nil {
return nil, err
}
return net.ParseIP("192.168.14.11"), nil
}
func (f *fakeHost) Sysctl(ns, key, value string) error {
return f.record(fmt.Sprintf("sysctl [%s] %s=%s", ns, key, value))
}
func (f *fakeHost) CreateVRF(name string, table uint32) error {
return f.record(fmt.Sprintf("vrf %s table %d", name, table))
}
func (f *fakeHost) CreateBridge(name string, mtu int, mac net.HardwareAddr) error {
return f.record(fmt.Sprintf("bridge %s mtu %d mac %s", name, mtu, mac))
}
func (f *fakeHost) SetMaster(iface, master string) error {
return f.record(fmt.Sprintf("master %s %s", iface, master))
}
func (f *fakeHost) CreateVxlan(name string, vni int, iface string, mtu int) error {
return f.record(fmt.Sprintf("vxlan %s id %d dev %s mtu %d", name, vni, iface, mtu))
}
func (f *fakeHost) CreateVeth(hostIf, nsIf, ns string, mtu int) error {
return f.record(fmt.Sprintf("veth %s peer %s netns %s mtu %d", hostIf, nsIf, ns, mtu))
}
func (f *fakeHost) AddrAdd(ns, iface string, prefix *net.IPNet) error {
return f.record(fmt.Sprintf("addr [%s] %s %s", ns, iface, prefix))
}
func (f *fakeHost) LinkUp(ns, iface string) error {
return f.record(fmt.Sprintf("up [%s] %s", ns, iface))
}
func (f *fakeHost) RouteVia(ns string, dst *net.IPNet, gw net.IP, iface string) error {
return f.record(fmt.Sprintf("route [%s] %s via %s dev %s", ns, dst, gw, iface))
}
func (f *fakeHost) DeleteLink(name string) error {
return f.record("del " + name)
}
func (f *fakeHost) TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error {
return f.record(fmt.Sprintf("table %d route %s via %s dev %s", table, dst, gw, iface))
}
func (f *fakeHost) TableRouteDel(table uint32, dst *net.IPNet) error {
return f.record(fmt.Sprintf("table %d del %s", table, dst))
}
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))
}
func (f *fakeHost) WithdrawVRF(v frr.VRF) error {
return f.record(fmt.Sprintf("frr withdraw asn=%d id=%s vni=%d", v.ASN, v.ID, v.L3VNI))
}
func (f *fakeHost) RemoveVRF(v frr.VRF) error {
return f.record(fmt.Sprintf("frr remove asn=%d id=%s vni=%d", v.ASN, v.ID, v.L3VNI))
}
func bgpConfig() *configuration.Config {
cfg := &configuration.Config{DefaultInterface: "br-000000"}
cfg.BGP.ASN = 64600
cfg.BGP.RouteReflectors = []string{"10.255.255.1"}
return cfg
}
func labL3(t *testing.T) l3VPC {
t.Helper()
_, supernet, err := net.ParseCIDR("10.241.0.0/16")
if err != nil {
t.Fatal(err)
}
return l3VPC{netns: "vp-s7", id: "s7", vni: 2700, supernet: supernet}
}
func TestCreateL3FollowsTheLabRecipe(t *testing.T) {
f := &fakeHost{}
if err := createL3(f, bgpConfig(), labL3(t)); err != nil {
t.Fatal(err)
}
want := []string{
"vtep br-000000",
"vrf vrf-s7 table 2700",
"bridge brl3-s7 mtu 1500 mac 02:02:c0:a8:0e:0b",
"master brl3-s7 vrf-s7",
"vxlan vxl3-s7 id 2700 dev br-000000 mtu 1500",
"master vxl3-s7 brl3-s7",
"up [] vxl3-s7",
"veth l3-s7-o peer l3-s7-i netns vp-s7 mtu 1500",
"master l3-s7-o vrf-s7",
"addr [] l3-s7-o 169.254.0.1/30",
"up [] l3-s7-o",
"sysctl [] net.ipv4.conf.brl3-s7.forwarding=1",
"sysctl [] net.ipv4.conf.l3-s7-o.forwarding=1",
"addr [vp-s7] l3-s7-i 169.254.0.2/30",
"up [vp-s7] l3-s7-i",
"sysctl [vp-s7] net.ipv4.ip_forward=1",
"route [vp-s7] 10.241.0.0/16 via 169.254.0.1 dev l3-s7-i",
"frr apply asn=64600 id=s7 vni=2700 vtep=192.168.14.11 supernet=10.241.0.0/16",
}
if !reflect.DeepEqual(f.calls, want) {
t.Errorf("appels :\n%s\nattendu :\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n"))
}
}
func TestCreateL3RequiresTheBGPSectionBeforeTouchingTheHost(t *testing.T) {
f := &fakeHost{}
cfg := &configuration.Config{DefaultInterface: "br-000000"}
if err := createL3(f, cfg, labL3(t)); err == nil || !strings.Contains(err.Error(), "no bgp section") {
t.Errorf("erreur %v", err)
}
if err := createL3(f, nil, labL3(t)); err == nil {
t.Error("config absente acceptée")
}
if len(f.calls) != 0 {
t.Errorf("appels : %q", f.calls)
}
}
func TestCreateL3StopsAtTheFirstFailure(t *testing.T) {
f := &fakeHost{fail: map[string]error{"vxlan ": errors.New("file exists")}}
err := createL3(f, bgpConfig(), labL3(t))
if err == nil || !strings.Contains(err.Error(), "l3vni 2700: create vxl3-s7: file exists") {
t.Errorf("erreur %v", err)
}
if last := f.calls[len(f.calls)-1]; !strings.HasPrefix(last, "vxlan ") {
t.Errorf("appels après l'échec : %q", f.calls)
}
}
func TestDeleteL3WithdrawsFRRThenTheKernelThenTheVRF(t *testing.T) {
f := &fakeHost{}
if err := deleteL3(f, labL3(t)); err != nil {
t.Fatal(err)
}
want := []string{
"frr withdraw asn=0 id=s7 vni=0",
"del l3-s7-o",
"del vxl3-s7",
"del brl3-s7",
"del vrf-s7",
"frr remove asn=0 id=s7 vni=0",
}
if !reflect.DeepEqual(f.calls, want) {
t.Errorf("appels :\n%s\nattendu :\n%s", strings.Join(f.calls, "\n"), strings.Join(want, "\n"))
}
}
func TestDeleteL3KeepsTheKernelWhenFRRRefusesTheWithdrawal(t *testing.T) {
f := &fakeHost{fail: map[string]error{"frr withdraw": errors.New("% Please unconfigure l3vni 2700")}}
err := deleteL3(f, labL3(t))
if err == nil || !strings.Contains(err.Error(), "withdraw frr") {
t.Errorf("erreur %v", err)
}
if len(f.calls) != 1 {
t.Errorf("le noyau a été touché malgré le refus de FRR : %q", f.calls)
}
}
func TestDeleteL3KeepsTheFRRVRFWhenAKernelLinkCannotBeDeleted(t *testing.T) {
f := &fakeHost{fail: map[string]error{"del brl3-s7": errors.New("device busy")}}
if err := deleteL3(f, labL3(t)); err == nil || !strings.Contains(err.Error(), "delete brl3-s7") {
t.Errorf("erreur %v", err)
}
for _, c := range f.calls {
if strings.HasPrefix(c, "frr remove") || c == "del vrf-s7" {
t.Errorf("étape exécutée après l'échec : %q", f.calls)
}
}
}
func TestDeleteL3DoesNotDependOnTheAgentBGPSection(t *testing.T) {
f := &fakeHost{}
if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 6 {
t.Errorf("erreur %v, appels %q", err, f.calls)
}
}
func TestRouterMAC(t *testing.T) {
mac, err := RouterMAC(net.ParseIP("192.168.14.11"))
if err != nil || mac.String() != "02:02:c0:a8:0e:0b" {
t.Errorf("RouterMAC = %v, %v", mac, err)
}
if _, err := RouterMAC(net.ParseIP("fd00::1")); err == nil {
t.Error("VTEP IPv6 accepté")
}
}
func TestLoadL3(t *testing.T) {
db := kv.InitDB(kv.Config{Path: t.TempDir()}, false)
t.Cleanup(func() { db.Close() })
kv.AddInDB(db, "vpc/vp-a/cidr", "10.241.0.0/16")
if _, ok, err := loadL3(db, "vp-a", "a"); ok || err != nil {
t.Errorf("VPC sans l3vni : ok=%v err=%v", ok, err)
}
kv.AddInDB(db, "vpc/vp-a/l3vni", "2700")
got, ok, err := loadL3(db, "vp-a", "a")
if !ok || err != nil || got.vni != 2700 || got.id != "a" || got.netns != "vp-a" || got.supernet.String() != "10.241.0.0/16" {
t.Errorf("loadL3 = %+v, %v, %v", got, ok, err)
}
for _, bad := range []string{"abc", "254", "0"} {
kv.AddInDB(db, "vpc/vp-a/l3vni", bad)
if _, _, err := loadL3(db, "vp-a", "a"); err == nil {
t.Errorf("l3vni %q acceptée", bad)
}
}
kv.AddInDB(db, "vpc/vp-b/l3vni", "2700")
if _, _, err := loadL3(db, "vp-b", "b"); err == nil || !strings.Contains(err.Error(), "no cidr") {
t.Errorf("VPC sans cidr : %v", err)
}
}
func TestLoadL3ReportsAReadErrorInsteadOfAVPCWithoutL3VNI(t *testing.T) {
db := kv.InitDB(kv.Config{Path: t.TempDir()}, false)
kv.AddInDB(db, "vpc/vp-a/cidr", "10.241.0.0/16")
kv.AddInDB(db, "vpc/vp-a/l3vni", "2700")
db.Close()
_, ok, err := loadL3(db, "vp-a", "a")
if ok || err == nil || !strings.Contains(err.Error(), "reading l3vni") {
t.Errorf("base fermée : ok=%v err=%v, erreur de lecture attendue", ok, err)
}
}

17
internal/l3vni/l3vni.go Normal file
View file

@ -0,0 +1,17 @@
package l3vni
import (
"fmt"
"git.g3e.fr/syonad/two/internal/frr"
)
func Valid(id uint32) error {
if id == 0 || id > frr.MaxL3VNI {
return fmt.Errorf("l3vni %d out of range 1-%d: the route distinguisher <vtep>:<l3vni> holds 16 bits", id, frr.MaxL3VNI)
}
if id >= 253 && id <= 255 {
return fmt.Errorf("l3vni %d is reserved: it is also the routing table id, and tables 253-255 belong to the kernel", id)
}
return nil
}

View file

@ -0,0 +1,30 @@
package l3vni
import (
"strings"
"testing"
)
func TestValid_AcceptsEvery16BitValueOutsideTheKernelTables(t *testing.T) {
for _, id := range []uint32{1, 252, 256, 4001, 65535} {
if err := Valid(id); err != nil {
t.Errorf("Valid(%d) = %v", id, err)
}
}
}
func TestValid_RejectsOutOfRangeAndReservedTables(t *testing.T) {
cases := map[uint32]string{
0: "out of range 1-65535",
65536: "out of range 1-65535",
16777215: "out of range 1-65535",
253: "is reserved",
254: "is reserved",
255: "is reserved",
}
for id, want := range cases {
if err := Valid(id); err == nil || !strings.Contains(err.Error(), want) {
t.Errorf("Valid(%d) = %v, attendu %q", id, err, want)
}
}
}

50
internal/l3vni/route.go Normal file
View file

@ -0,0 +1,50 @@
package l3vni
import (
"fmt"
"net"
"strings"
"github.com/dgraph-io/badger/v4"
)
func ExportRoute(db *badger.DB, vpcName string, dst *net.IPNet) error {
return exportRoute(newSystem(), db, vpcName, dst)
}
func WithdrawRoute(db *badger.DB, vpcName string, dst *net.IPNet) error {
return withdrawRoute(newSystem(), db, vpcName, dst)
}
func loadRouted(db *badger.DB, vpcName string) (l3VPC, bool, error) {
parts := strings.SplitN(vpcName, "-", 2)
if len(parts) != 2 {
return l3VPC{}, false, fmt.Errorf("invalid vpc name %q", vpcName)
}
return loadL3(db, vpcName, parts[1])
}
func exportRoute(h host, db *badger.DB, vpcName string, dst *net.IPNet) error {
v, ok, err := loadRouted(db, vpcName)
if err != nil || !ok {
return err
}
if !v.supernet.Contains(dst.IP) {
return fmt.Errorf("vpc %q: %s is outside %s", vpcName, dst, v.supernet)
}
if err := h.TableRouteVia(v.vni, dst, transitNetns.IP, v.vethHost()); err != nil {
return fmt.Errorf("export %s in %s: %w", dst, v.vrf(), err)
}
return nil
}
func withdrawRoute(h host, db *badger.DB, vpcName string, dst *net.IPNet) error {
v, ok, err := loadRouted(db, vpcName)
if err != nil || !ok {
return err
}
if err := h.TableRouteDel(v.vni, dst); err != nil {
return fmt.Errorf("withdraw %s from %s: %w", dst, v.vrf(), err)
}
return nil
}

View file

@ -0,0 +1,89 @@
package l3vni
import (
"errors"
"net"
"reflect"
"strings"
"testing"
"git.g3e.fr/syonad/two/pkg/db/kv"
"github.com/dgraph-io/badger/v4"
)
func routedDB(t *testing.T) *badger.DB {
t.Helper()
db := kv.InitDB(kv.Config{Path: t.TempDir()}, false)
t.Cleanup(func() { db.Close() })
kv.AddInDB(db, "vpc/vp-s7/cidr", "10.241.0.0/16")
kv.AddInDB(db, "vpc/vp-s7/l3vni", "2700")
kv.AddInDB(db, "vpc/vp-flat/cidr", "10.242.0.0/16")
return db
}
func cidr(t *testing.T, s string) *net.IPNet {
t.Helper()
_, n, err := net.ParseCIDR(s)
if err != nil {
t.Fatal(err)
}
return n
}
func TestExportRouteInstallsTheRouteInTheVRFTowardsTheNetns(t *testing.T) {
f := &fakeHost{}
if err := exportRoute(f, routedDB(t), "vp-s7", cidr(t, "10.241.1.0/24")); err != nil {
t.Fatal(err)
}
want := []string{"table 2700 route 10.241.1.0/24 via 169.254.0.2 dev l3-s7-o"}
if !reflect.DeepEqual(f.calls, want) {
t.Errorf("appels %q, attendu %q", f.calls, want)
}
}
func TestExportRouteRefusesAPrefixOutsideTheVPC(t *testing.T) {
f := &fakeHost{}
err := exportRoute(f, routedDB(t), "vp-s7", cidr(t, "10.99.1.0/24"))
if err == nil || !strings.Contains(err.Error(), "outside 10.241.0.0/16") || len(f.calls) != 0 {
t.Errorf("erreur %v, appels %q", err, f.calls)
}
}
func TestWithdrawRouteDeletesFromTheVRFTable(t *testing.T) {
f := &fakeHost{}
if err := withdrawRoute(f, routedDB(t), "vp-s7", cidr(t, "10.241.1.10/32")); err != nil {
t.Fatal(err)
}
want := []string{"table 2700 del 10.241.1.10/32"}
if !reflect.DeepEqual(f.calls, want) {
t.Errorf("appels %q, attendu %q", f.calls, want)
}
}
func TestRoutesAreIgnoredForAVPCWithoutL3VNI(t *testing.T) {
f := &fakeHost{}
db := routedDB(t)
if err := exportRoute(f, db, "vp-flat", cidr(t, "10.242.1.0/24")); err != nil {
t.Error(err)
}
if err := withdrawRoute(f, db, "vp-flat", cidr(t, "10.242.1.0/24")); err != nil {
t.Error(err)
}
if len(f.calls) != 0 {
t.Errorf("appels %q", f.calls)
}
}
func TestRouteErrorsArePropagated(t *testing.T) {
db := routedDB(t)
f := &fakeHost{fail: map[string]error{"table ": errors.New("network unreachable")}}
if err := exportRoute(f, db, "vp-s7", cidr(t, "10.241.1.0/24")); err == nil || !strings.Contains(err.Error(), "export 10.241.1.0/24 in vrf-s7") {
t.Errorf("export : %v", err)
}
if err := withdrawRoute(f, db, "vp-s7", cidr(t, "10.241.1.0/24")); err == nil || !strings.Contains(err.Error(), "withdraw 10.241.1.0/24 from vrf-s7") {
t.Errorf("withdraw : %v", err)
}
if err := exportRoute(f, db, "novpc", cidr(t, "10.241.1.0/24")); err == nil {
t.Error("nom de VPC sans tiret accepté")
}
}

View file

@ -147,7 +147,7 @@ func TestRoles_ProvisioningIsOneScriptThatStopsAtTheFirstFailure(t *testing.T) {
nodes := renderRoles(t)
for name, steps := range map[string]string{
"sw1": "systemctl daemon-reload\nsystemctl enable --now lab-switch.service\n/usr/local/sbin/lab-frr\n",
"hv1": "/usr/local/sbin/lab-deploy\n/usr/local/sbin/lab-frr\n",
"hv1": "/usr/local/sbin/lab-deploy\n/usr/local/sbin/lab-frr\nsystemctl restart agent.service\n",
"hv2": "/usr/local/sbin/lab-deploy\n",
} {
cfg := user(t, nodeNamed(t, nodes, name))

View file

@ -133,6 +133,9 @@ func userData(p *topology.Plan, n topology.NodePlan, o Options) ([]byte, error)
writeFile{Path: FRRScript, Permissions: "0755", Content: frrScript(n)},
)
steps = append(steps, FRRScript)
if n.Role == topology.RoleHypervisor {
steps = append(steps, "systemctl restart agent.service")
}
}
if len(steps) > 0 {
cfg.WriteFiles = append(cfg.WriteFiles,

View file

@ -19,3 +19,11 @@ func AddrAdd(iface string, ip net.IP) error {
}
return netlink.AddrAdd(link, addr)
}
func AddrAddPrefix(iface string, prefix *net.IPNet) error {
link, err := netlink.LinkByName(iface)
if err != nil {
return err
}
return netlink.AddrAdd(link, &netlink.Addr{IPNet: prefix})
}

View file

@ -1,14 +1,17 @@
package netif
import (
"net"
"github.com/vishvananda/netlink"
)
func CreateBridge(name string, mtu int) error {
func CreateBridge(name string, mtu int, mac net.HardwareAddr) error {
br := &netlink.Bridge{
LinkAttrs: netlink.LinkAttrs{
Name: name,
MTU: mtu,
Name: name,
MTU: mtu,
HardwareAddr: mac,
},
}

View file

@ -1,6 +1,8 @@
package netif
import (
"errors"
"github.com/vishvananda/netlink"
)
@ -11,3 +13,15 @@ func DeleteLink(name string) error {
}
return netlink.LinkDel(link)
}
func DeleteLinkIfExists(name string) error {
link, err := netlink.LinkByName(name)
if err != nil {
var notFound netlink.LinkNotFoundError
if errors.As(err, &notFound) {
return nil
}
return err
}
return netlink.LinkDel(link)
}

21
internal/netif/mac.go Normal file
View file

@ -0,0 +1,21 @@
package netif
import (
"fmt"
"net"
)
const (
locallyAdministered byte = 0x02
RoleRouter byte = 0x02
RoleHostGateway byte = 0x03
)
func HostMAC(role byte, vtep net.IP) (net.HardwareAddr, error) {
ip := vtep.To4()
if ip == nil {
return nil, fmt.Errorf("vtep %v is not an IPv4 address", vtep)
}
return net.HardwareAddr{locallyAdministered, role, ip[0], ip[1], ip[2], ip[3]}, nil
}

View file

@ -0,0 +1,60 @@
package netif
import (
"net"
"testing"
)
func TestHostMAC(t *testing.T) {
cases := []struct {
role byte
vtep string
want string
}{
{RoleHostGateway, "192.168.14.11", "02:03:c0:a8:0e:0b"},
{RoleHostGateway, "192.168.14.12", "02:03:c0:a8:0e:0c"},
{RoleHostGateway, "10.0.0.1", "02:03:0a:00:00:01"},
{RoleRouter, "192.168.14.11", "02:02:c0:a8:0e:0b"},
}
for _, c := range cases {
got, err := HostMAC(c.role, net.ParseIP(c.vtep))
if err != nil {
t.Fatalf("rôle %#x, VTEP %s : erreur inattendue %v", c.role, c.vtep, err)
}
if got.String() != c.want {
t.Errorf("rôle %#x, VTEP %s : %s, %s attendu", c.role, c.vtep, got, c.want)
}
}
}
func TestHostMACIsLocalUnicast(t *testing.T) {
for _, role := range []byte{RoleRouter, RoleHostGateway} {
got, err := HostMAC(role, net.ParseIP("192.168.14.11"))
if err != nil {
t.Fatal(err)
}
if got[0]&0x02 == 0 {
t.Errorf("%s : bit « administrée localement » absent", got)
}
if got[0]&0x01 != 0 {
t.Errorf("%s : MAC de groupe (multicast)", got)
}
}
}
func TestHostMACRolesDifferOnTheSameHost(t *testing.T) {
if RoleRouter == RoleHostGateway {
t.Fatalf("rôles identiques : %#x", RoleRouter)
}
if RoleRouter != 0x02 || RoleHostGateway != 0x03 {
t.Errorf("rôles %#x / %#x, 0x02 / 0x03 attendus (valeurs publiées dans la doc)", RoleRouter, RoleHostGateway)
}
}
func TestHostMACRejectsANonIPv4VTEP(t *testing.T) {
for _, vtep := range []net.IP{nil, net.ParseIP("fd00::1")} {
if mac, err := HostMAC(RoleHostGateway, vtep); err == nil {
t.Errorf("VTEP %v accepté : %s", vtep, mac)
}
}
}

36
internal/netif/route.go Normal file
View file

@ -0,0 +1,36 @@
package netif
import (
"errors"
"net"
"syscall"
"github.com/vishvananda/netlink"
)
func RouteReplaceVia(table int, dst *net.IPNet, gw net.IP, iface string) error {
link, err := netlink.LinkByName(iface)
if err != nil {
return err
}
return netlink.RouteReplace(&netlink.Route{
LinkIndex: link.Attrs().Index,
Dst: dst,
Gw: gw,
Table: table,
})
}
func RouteDel(table int, dst *net.IPNet) error {
return netlink.RouteDel(&netlink.Route{
Dst: dst,
Table: table,
})
}
func RouteDelIfExists(table int, dst *net.IPNet) error {
if err := RouteDel(table, dst); err != nil && !errors.Is(err, syscall.ESRCH) {
return err
}
return nil
}

View file

@ -19,3 +19,24 @@ func RouteAdd(iface string, subnet *net.IPNet) error {
Scope: netlink.SCOPE_LINK,
})
}
func TableRoutesVia(table int, iface string) ([]*net.IPNet, error) {
link, err := netlink.LinkByName(iface)
if err != nil {
return nil, err
}
routes, err := netlink.RouteListFiltered(netlink.FAMILY_V4, &netlink.Route{
Table: table,
LinkIndex: link.Attrs().Index,
}, netlink.RT_FILTER_TABLE|netlink.RT_FILTER_OIF)
if err != nil {
return nil, err
}
dsts := make([]*net.IPNet, 0, len(routes))
for _, r := range routes {
if r.Dst != nil && r.Gw != nil {
dsts = append(dsts, r.Dst)
}
}
return dsts, nil
}

View file

@ -2,8 +2,15 @@
package netif
import "net"
import (
"errors"
"net"
)
func RouteAdd(_ string, _ *net.IPNet) error {
return nil
return errors.New("not supported on this platform")
}
func TableRoutesVia(_ int, _ string) ([]*net.IPNet, error) {
return nil, errors.New("route listing is only implemented on linux")
}

16
internal/netif/vrf.go Normal file
View file

@ -0,0 +1,16 @@
package netif
import (
"github.com/vishvananda/netlink"
)
func CreateVRF(name string, table uint32) error {
vrf := &netlink.Vrf{
LinkAttrs: netlink.LinkAttrs{Name: name},
Table: table,
}
if err := netlink.LinkAdd(vrf); err != nil {
return err
}
return netlink.LinkSetUp(vrf)
}

View file

@ -18,11 +18,7 @@ func CreateVxlan(name string, vxlanID int, localIface string, mtu int) error {
if err != nil {
return err
}
addrs, err := netlink.AddrList(link, syscall.AF_INET)
if err != nil {
return err
}
local, err := vtepAddress(localIface, addrs)
local, err := linkVTEPAddress(link)
if err != nil {
return err
}
@ -40,6 +36,22 @@ func CreateVxlan(name string, vxlanID int, localIface string, mtu int) error {
return netlink.LinkAdd(vxlan)
}
func VTEPAddress(iface string) (net.IP, error) {
link, err := netlink.LinkByName(iface)
if err != nil {
return nil, err
}
return linkVTEPAddress(link)
}
func linkVTEPAddress(link netlink.Link) (net.IP, error) {
addrs, err := netlink.AddrList(link, syscall.AF_INET)
if err != nil {
return nil, err
}
return vtepAddress(link.Attrs().Name, addrs)
}
func vtepAddress(iface string, addrs []netlink.Addr) (net.IP, error) {
for _, a := range addrs {
if a.IPNet == nil || a.IP.To4() == nil || a.Scope != scopeUniverse || a.Flags&addressSecondary != 0 {

View file

@ -2,11 +2,13 @@ package subnet
import (
"fmt"
"net"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/dhcp"
"git.g3e.fr/syonad/two/internal/dhcpbackend"
"git.g3e.fr/syonad/two/internal/ebtables"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/netns"
"git.g3e.fr/syonad/two/internal/state"
@ -37,6 +39,12 @@ func CreateSubnet(db *badger.DB, subnetName string, cfg *configuration.Config) e
return err
}
if d.mode == ModeVxlan {
if err := l3vni.ExportRoute(db, d.vpc, d.cidr); err != nil {
return err
}
}
return state.Set(db, "subnet/"+subnetName, state.Running)
}
@ -66,8 +74,19 @@ func createSubnet(db *badger.DB, subnetName string, d subnetData, backend dhcpba
return fmt.Errorf("unknown subnet mode %q", d.mode)
}
var gatewayMAC net.HardwareAddr
if d.mode == ModeVxlan {
vtep, err := netif.VTEPAddress(d.localIface)
if err != nil {
return fmt.Errorf("vtep of %s: %w", d.localIface, err)
}
if gatewayMAC, err = netif.HostMAC(netif.RoleHostGateway, vtep); err != nil {
return err
}
}
if err := netns.Call(d.vpc, func() error {
if err := netif.CreateBridge(d.bridge, 1500); err != nil {
if err := netif.CreateBridge(d.bridge, 1500, gatewayMAC); err != nil {
return fmt.Errorf("create bridge: %w", err)
}
return netif.BridgeSetMaster(vethI, d.bridge)
@ -122,7 +141,7 @@ func createSubnet(db *badger.DB, subnetName string, d subnetData, backend dhcpba
func setupVxlanHost(d subnetData, vethE string) error {
vxlanIface := fmt.Sprintf("vxlan-%d", d.vxlanID)
if err := netif.CreateBridge(d.bridge, 1500); err != nil {
if err := netif.CreateBridge(d.bridge, 1500, nil); err != nil {
return fmt.Errorf("create bridge: %w", err)
}
if err := netif.CreateVxlan(vxlanIface, d.vxlanID, d.localIface, 1500); err != nil {

View file

@ -6,6 +6,7 @@ import (
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/dhcpbackend"
"git.g3e.fr/syonad/two/internal/ebtables"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/netns"
"git.g3e.fr/syonad/two/internal/state"
@ -33,6 +34,12 @@ func DeleteSubnet(db *badger.DB, subnetName string, cfg *configuration.Config) e
return err
}
if d.mode == ModeVxlan {
if err := l3vni.WithdrawRoute(db, d.vpc, d.cidr); err != nil {
return err
}
}
if err := stopDHCP(db, subnetName, d, backend); err != nil {
return err
}

23
internal/sysctl/sysctl.go Normal file
View file

@ -0,0 +1,23 @@
package sysctl
import (
"fmt"
"os"
"path/filepath"
"strings"
)
var root = "/proc/sys"
func Set(key, value string) error {
path := filepath.Join(root, strings.ReplaceAll(key, ".", "/"))
f, err := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0)
if err != nil {
return fmt.Errorf("sysctl %s: %w", key, err)
}
if _, err := f.WriteString(value); err != nil {
f.Close()
return fmt.Errorf("sysctl %s=%s: %w", key, value, err)
}
return f.Close()
}

View file

@ -0,0 +1,48 @@
package sysctl
import (
"os"
"path/filepath"
"strings"
"testing"
)
func fakeRoot(t *testing.T) string {
t.Helper()
dir := t.TempDir()
if err := os.MkdirAll(filepath.Join(dir, "net", "ipv4"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "net", "ipv4", "ip_forward"), []byte("0\n"), 0o644); err != nil {
t.Fatal(err)
}
old := root
root = dir
t.Cleanup(func() { root = old })
return dir
}
func TestSetWritesTheValueAtTheKeyPath(t *testing.T) {
dir := fakeRoot(t)
if err := Set("net.ipv4.ip_forward", "1"); err != nil {
t.Fatal(err)
}
got, err := os.ReadFile(filepath.Join(dir, "net", "ipv4", "ip_forward"))
if err != nil {
t.Fatal(err)
}
if string(got) != "1" {
t.Errorf("contenu %q, \"1\" attendu", got)
}
}
func TestSetRefusesAnUnknownKeyWithoutCreatingIt(t *testing.T) {
dir := fakeRoot(t)
err := Set("net.ipv4.ip_forwarding", "1")
if err == nil || !strings.Contains(err.Error(), "sysctl net.ipv4.ip_forwarding") {
t.Errorf("erreur %v", err)
}
if _, err := os.Stat(filepath.Join(dir, "net", "ipv4", "ip_forwarding")); !os.IsNotExist(err) {
t.Errorf("clé inconnue créée : %v", err)
}
}

View file

@ -10,6 +10,7 @@ import (
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/dhcpbackend"
"git.g3e.fr/syonad/two/internal/iptables"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/internal/metadata"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/netns"
@ -111,6 +112,10 @@ func StartVM(db *badger.DB, name string, cfg *configuration.Config) error {
return fmt.Errorf("start qemu: %w", err)
}
if err := applyHostRoutes(db, d, l3vni.ExportRoute); err != nil {
return err
}
return state.Set(db, "vm/"+name, state.Running)
}

View file

@ -9,6 +9,7 @@ import (
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/dhcpbackend"
"git.g3e.fr/syonad/two/internal/iptables"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/internal/metadata"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/netns"
@ -38,6 +39,10 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error {
return err
}
if err := applyHostRoutes(db, d, l3vni.WithdrawRoute); err != nil {
return err
}
socketPath := filepath.Join(cfg.QEMU.QMPDir, name+".sock")
if _, err := os.Stat(socketPath); err == nil {

43
internal/vm/routes.go Normal file
View file

@ -0,0 +1,43 @@
package vm
import (
"fmt"
"net"
"github.com/dgraph-io/badger/v4"
)
type hostRoute struct {
vpc string
dst *net.IPNet
}
type routeFunc func(db *badger.DB, vpcName string, dst *net.IPNet) error
func hostRoutes(d vmData) ([]hostRoute, error) {
var routes []hostRoute
for _, n := range d.nics {
if n.mode != "vxlan" {
continue
}
ip := net.ParseIP(n.ip).To4()
if ip == nil {
return nil, fmt.Errorf("interface %d: %q is not an IPv4 address", n.index, n.ip)
}
routes = append(routes, hostRoute{vpc: n.vpcName, dst: &net.IPNet{IP: ip, Mask: net.CIDRMask(32, 32)}})
}
return routes, nil
}
func applyHostRoutes(db *badger.DB, d vmData, apply routeFunc) error {
routes, err := hostRoutes(d)
if err != nil {
return err
}
for _, r := range routes {
if err := apply(db, r.vpc, r.dst); err != nil {
return err
}
}
return nil
}

View file

@ -0,0 +1,66 @@
package vm
import (
"errors"
"net"
"reflect"
"strings"
"testing"
"github.com/dgraph-io/badger/v4"
)
func routedVM() vmData {
return vmData{nics: []nicData{
{index: 0, vpcName: "vp-s7", mode: "vxlan", ip: "10.241.1.10"},
{index: 1, vpcName: "vp-s7", mode: "bridge", ip: "192.168.50.10"},
{index: 2, vpcName: "vp-s7", mode: "vxlan", ip: "10.241.2.10"},
}}
}
type recorder struct {
calls []string
fail string
}
func (r *recorder) apply(_ *badger.DB, vpcName string, dst *net.IPNet) error {
r.calls = append(r.calls, vpcName+" "+dst.String())
if dst.String() == r.fail {
return errors.New("refused")
}
return nil
}
func TestApplyHostRoutesCoversEveryVxlanInterfaceAsA32(t *testing.T) {
r := &recorder{}
if err := applyHostRoutes(nil, routedVM(), r.apply); err != nil {
t.Fatal(err)
}
want := []string{"vp-s7 10.241.1.10/32", "vp-s7 10.241.2.10/32"}
if !reflect.DeepEqual(r.calls, want) {
t.Errorf("appels %q, attendu %q", r.calls, want)
}
}
func TestApplyHostRoutesStopsAtTheFirstError(t *testing.T) {
r := &recorder{fail: "10.241.1.10/32"}
if err := applyHostRoutes(nil, routedVM(), r.apply); err == nil || err.Error() != "refused" {
t.Errorf("erreur %v", err)
}
if len(r.calls) != 1 {
t.Errorf("appels après l'échec : %q", r.calls)
}
}
func TestApplyHostRoutesRefusesANonIPv4AddressBeforeAnyCall(t *testing.T) {
d := routedVM()
d.nics[2].ip = "fd00::10"
r := &recorder{}
err := applyHostRoutes(nil, d, r.apply)
if err == nil || !strings.Contains(err.Error(), `interface 2: "fd00::10" is not an IPv4 address`) {
t.Errorf("erreur %v", err)
}
if len(r.calls) != 0 {
t.Errorf("appels : %q", r.calls)
}
}

View file

@ -3,6 +3,8 @@ package vpc
import (
"strings"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/netns"
"git.g3e.fr/syonad/two/internal/state"
@ -10,7 +12,7 @@ import (
"github.com/dgraph-io/badger/v4"
)
func CreateVPC(db *badger.DB, name string) error {
func CreateVPC(db *badger.DB, name string, cfg *configuration.Config) error {
if current, err := state.Get(db, "vpc/"+name); err != nil {
return err
} else if current == state.Creating {
@ -25,7 +27,7 @@ func CreateVPC(db *badger.DB, name string) error {
}
if err := netns.Call(name, func() error {
return netif.CreateBridge("br-public", 1500)
return netif.CreateBridge("br-public", 1500, nil)
}); err != nil {
return err
}
@ -48,6 +50,9 @@ func CreateVPC(db *badger.DB, name string) error {
}); err != nil {
return err
}
if err := l3vni.Create(db, name, cfg); err != nil {
return err
}
return state.Set(db, "vpc/"+name, state.Running)
}
return nil

View file

@ -3,6 +3,7 @@ package vpc
import (
"strings"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/netns"
"git.g3e.fr/syonad/two/internal/state"
@ -16,6 +17,10 @@ func DeleteVPC(db *badger.DB, name string) error {
} else if current == state.Deleting {
vpcID := strings.SplitN(name, "-", 2)[1]
if err := l3vni.Delete(db, name); err != nil {
return err
}
if err := netif.DeleteLink("vp-" + vpcID + "-e"); err != nil {
return err
}

View file

@ -0,0 +1,232 @@
package watchdog
import (
"fmt"
"net"
"sort"
"strings"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/internal/l3vni"
"git.g3e.fr/syonad/two/internal/netif"
"git.g3e.fr/syonad/two/internal/netns"
"git.g3e.fr/syonad/two/internal/state"
"git.g3e.fr/syonad/two/internal/watchdog/notify"
"git.g3e.fr/syonad/two/pkg/db/kv"
"github.com/dgraph-io/badger/v4"
)
const kindBGP = "bgp"
type l3Probe interface {
VTEPAddress(iface string) (net.IP, error)
NeighborEstablished(peer net.IP) (bool, error)
VNI(vni uint32) (frr.VNIState, error)
ExportedRoutes(table uint32, iface string) ([]*net.IPNet, error)
LinkProblem(ns, iface string) string
}
type systemProbe struct {
frr *frr.Client
}
func (systemProbe) VTEPAddress(iface string) (net.IP, error) { return netif.VTEPAddress(iface) }
func (p systemProbe) NeighborEstablished(peer net.IP) (bool, error) {
return p.frr.NeighborEstablished(peer)
}
func (p systemProbe) VNI(vni uint32) (frr.VNIState, error) { return p.frr.VNI(vni) }
func (systemProbe) ExportedRoutes(table uint32, iface string) ([]*net.IPNet, error) {
return netif.TableRoutesVia(int(table), iface)
}
func (systemProbe) LinkProblem(ns, iface string) string {
if ns == "" {
return linkProblem(iface)
}
var p string
if err := netns.Call(ns, func() error {
p = linkProblem(iface)
return nil
}); err != nil {
return fmt.Sprintf("cannot enter netns %s: %v", ns, err)
}
if p != "" {
return p + " (in netns)"
}
return ""
}
func CheckBGP(cfg *configuration.Config, p l3Probe, n notify.Notifier) {
if !cfg.BGP.Enabled() {
return
}
reflectors, err := cfg.BGP.Reflectors()
if err != nil {
n.Notify(kindBGP, "config", err.Error())
return
}
for _, rr := range reflectors {
up, err := p.NeighborEstablished(rr)
switch {
case err != nil:
n.Notify(kindBGP, rr.String(), fmt.Sprintf("session unreadable: %v", err))
case !up:
n.Notify(kindBGP, rr.String(), "session to the route reflector is not established")
}
}
}
func CheckL3VPCs(db *badger.DB, cfg *configuration.Config, p l3Probe, n notify.Notifier) error {
pairs, err := kv.ListByPrefix(db, prefixVPC)
if err != nil {
return fmt.Errorf("watchdog: listing vpcs: %w", err)
}
var rmac string
for _, name := range resourceNames(pairs, prefixVPC) {
if st, err := state.Get(db, prefixVPC+name); err != nil || st != state.Running {
continue
}
r, ok, err := l3vni.LoadRouting(db, name)
if err != nil {
n.Notify(kindVPC, name, err.Error())
continue
}
if !ok {
continue
}
if !cfg.BGP.Enabled() {
n.Notify(kindVPC, name, "vpc has an l3vni but the agent configuration has no bgp section")
continue
}
if rmac == "" {
rmac = expectedRouterMAC(cfg, p, n)
}
checkL3VPC(db, name, r, rmac, p, n)
}
return nil
}
func expectedRouterMAC(cfg *configuration.Config, p l3Probe, n notify.Notifier) string {
vtep, err := p.VTEPAddress(cfg.DefaultInterface)
if err != nil {
n.Notify(kindBGP, "vtep", fmt.Sprintf("vtep address unreadable on %s: %v", cfg.DefaultInterface, err))
return "unknown"
}
mac, err := l3vni.RouterMAC(vtep)
if err != nil {
n.Notify(kindBGP, "vtep", err.Error())
return "unknown"
}
return mac.String()
}
func checkL3VPC(db *badger.DB, name string, r l3vni.Routing, rmac string, p l3Probe, n notify.Notifier) {
for _, iface := range []string{r.VRF, r.Bridge, r.Vxlan, r.VethHost} {
if problem := p.LinkProblem("", iface); problem != "" {
n.Notify(kindVPC, name, problem)
}
}
if problem := p.LinkProblem(name, r.VethNetns); problem != "" {
n.Notify(kindVPC, name, problem)
}
s, err := p.VNI(r.VNI)
switch {
case err != nil:
n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d unreadable in frr: %v", r.VNI, err))
case s.Type != "L3" || s.State != "Up":
n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d is type %q state %q in frr, expected L3 Up", r.VNI, s.Type, s.State))
case rmac != "unknown" && s.RouterMAC != rmac:
n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d has router mac %q in frr, expected %s", r.VNI, s.RouterMAC, rmac))
}
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))
return
}
expected, tolerated, err := expectedExports(db, name)
if err != nil {
n.Notify(kindVPC, name, err.Error())
return
}
exported := make(map[string]bool, len(actual))
for _, dst := range actual {
exported[dst.String()] = true
}
for _, dst := range sortedKeys(exported) {
if !expected[dst] && !tolerated[dst] {
n.Notify(kindVPC, name, fmt.Sprintf("route %s exported in %s without a running owner: its traffic is black-holed", dst, r.VRF))
}
}
for _, dst := range sortedKeys(expected) {
if !exported[dst] {
n.Notify(kindVPC, name, fmt.Sprintf("route %s not exported in %s", dst, r.VRF))
}
}
}
func expectedExports(db *badger.DB, vpcName string) (expected, tolerated map[string]bool, err error) {
expected, tolerated = map[string]bool{}, map[string]bool{}
classify := func(st state.State, dst string) {
switch st {
case state.Running:
expected[dst] = true
case state.Creating, state.Deleting, state.Error:
tolerated[dst] = true
}
}
subnets, err := kv.ListByPrefix(db, prefixSubnet)
if err != nil {
return nil, nil, fmt.Errorf("watchdog: listing subnets: %w", err)
}
routed := map[string]bool{}
for key, value := range subnets {
subnet, ok := strings.CutSuffix(strings.TrimPrefix(key, prefixSubnet), "/vpc")
if !ok || strings.Contains(subnet, "/") || value != vpcName || subnets[prefixSubnet+subnet+"/mode"] != "vxlan" {
continue
}
routed[subnet] = true
_, cidr, err := net.ParseCIDR(subnets[prefixSubnet+subnet+"/cidr"])
if err != nil {
continue
}
if st, err := state.Get(db, prefixSubnet+subnet); err == nil {
classify(st, cidr.String())
}
}
vms, err := kv.ListByPrefix(db, prefixVM)
if err != nil {
return nil, nil, fmt.Errorf("watchdog: listing vms: %w", err)
}
for key, value := range vms {
parts := strings.Split(key, "/")
if len(parts) != 5 || parts[2] != "nic" || parts[4] != "subnet" || !routed[value] {
continue
}
ip := net.ParseIP(vms[strings.TrimSuffix(key, "subnet")+"ip"]).To4()
if ip == nil {
continue
}
if st, err := state.Get(db, prefixVM+parts[1]); err == nil {
classify(st, ip.String()+"/32")
}
}
return expected, tolerated, nil
}
func sortedKeys(m map[string]bool) []string {
keys := make([]string, 0, len(m))
for k := range m {
keys = append(keys, k)
}
sort.Strings(keys)
return keys
}

View file

@ -0,0 +1,242 @@
package watchdog
import (
"errors"
"net"
"reflect"
"testing"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/internal/state"
)
type fakeProbe struct {
established map[string]bool
neighborErr error
vni map[uint32]frr.VNIState
routes map[uint32][]string
routesErr error
links map[string]string
vtepErr error
}
func (f *fakeProbe) VTEPAddress(string) (net.IP, error) {
if f.vtepErr != nil {
return nil, f.vtepErr
}
return net.ParseIP("192.168.14.11"), nil
}
func (f *fakeProbe) NeighborEstablished(peer net.IP) (bool, error) {
return f.established[peer.String()], f.neighborErr
}
func (f *fakeProbe) VNI(vni uint32) (frr.VNIState, error) {
s, ok := f.vni[vni]
if !ok {
return s, errors.New("% VNI does not exist")
}
return s, nil
}
func (f *fakeProbe) ExportedRoutes(table uint32, _ string) ([]*net.IPNet, error) {
var out []*net.IPNet
for _, r := range f.routes[table] {
_, n, _ := net.ParseCIDR(r)
out = append(out, n)
}
return out, f.routesErr
}
func (f *fakeProbe) LinkProblem(ns, iface string) string {
return f.links[ns+"/"+iface]
}
func bgpCfg() *configuration.Config {
cfg := &configuration.Config{DefaultInterface: "br-000000"}
cfg.BGP.ASN = 64600
cfg.BGP.RouteReflectors = []string{"10.255.255.1", "10.255.255.2"}
return cfg
}
func notified(r *recorder) []string {
var out []string
for _, c := range r.calls {
out = append(out, c.kind+" "+c.name+": "+c.problem)
}
return out
}
func TestCheckBGPReportsEachReflectorWithoutSession(t *testing.T) {
r := &recorder{}
CheckBGP(bgpCfg(), &fakeProbe{established: map[string]bool{"10.255.255.1": true}}, r)
want := []string{"bgp 10.255.255.2: session to the route reflector is not established"}
if got := notified(r); !reflect.DeepEqual(got, want) {
t.Errorf("notifications %q, attendu %q", got, want)
}
}
func TestCheckBGPReportsAnUnreadableSession(t *testing.T) {
r := &recorder{}
CheckBGP(bgpCfg(), &fakeProbe{neighborErr: errors.New("vtysh absent")}, r)
if len(r.calls) != 2 || !r.hasProblemContaining("session unreadable: vtysh absent") {
t.Errorf("notifications %q", notified(r))
}
}
func TestCheckBGPIsSilentWithoutBGPSection(t *testing.T) {
r := &recorder{}
CheckBGP(&configuration.Config{}, &fakeProbe{}, r)
if len(r.calls) != 0 {
t.Errorf("notifications %q", notified(r))
}
}
func seedRoutedVPC(t *testing.T) *fakeProbe {
return &fakeProbe{
vni: map[uint32]frr.VNIState{2700: {Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:0b"}},
}
}
func TestCheckL3VPCsReconcilesExportedRoutesWithTheirOwners(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-flat", state.Running)
seedKV(t, db, "vpc/vp-flat/cidr", "10.242.0.0/16")
seedResource(t, db, prefixSubnet, "sn-a", state.Running)
seedKV(t, db, "subnet/sn-a/vpc", "vp-s7")
seedKV(t, db, "subnet/sn-a/mode", "vxlan")
seedKV(t, db, "subnet/sn-a/cidr", "10.241.1.0/24")
seedResource(t, db, prefixSubnet, "sn-b", state.Creating)
seedKV(t, db, "subnet/sn-b/vpc", "vp-s7")
seedKV(t, db, "subnet/sn-b/mode", "vxlan")
seedKV(t, db, "subnet/sn-b/cidr", "10.241.2.0/24")
seedResource(t, db, prefixSubnet, "sn-br", state.Running)
seedKV(t, db, "subnet/sn-br/vpc", "vp-s7")
seedKV(t, db, "subnet/sn-br/mode", "bridge")
seedKV(t, db, "subnet/sn-br/cidr", "192.168.50.0/24")
vm := func(name string, st state.State, subnet, ip string) {
seedResource(t, db, prefixVM, name, st)
seedKV(t, db, "vm/"+name+"/nic/0/subnet", subnet)
seedKV(t, db, "vm/"+name+"/nic/0/ip", ip)
}
vm("i-run", state.Running, "sn-a", "10.241.1.10")
vm("i-missing", state.Running, "sn-a", "10.241.1.11")
vm("i-starting", state.Creating, "sn-a", "10.241.1.12")
vm("i-gone", state.Deleted, "sn-a", "10.241.1.13")
vm("i-bridge", state.Running, "sn-br", "192.168.50.10")
seedResource(t, db, prefixSubnet, "sn-flat", state.Running)
seedKV(t, db, "subnet/sn-flat/vpc", "vp-flat")
seedKV(t, db, "subnet/sn-flat/mode", "vxlan")
seedKV(t, db, "subnet/sn-flat/cidr", "10.242.1.0/24")
vm("i-flat", state.Running, "sn-flat", "10.242.1.10")
p := seedRoutedVPC(t)
p.routes = map[uint32][]string{2700: {
"10.241.1.0/24", "10.241.2.0/24",
"10.241.1.10/32", "10.241.1.12/32", "10.241.1.13/32", "10.241.1.50/32",
}}
r := &recorder{}
if err := CheckL3VPCs(db, bgpCfg(), p, r); err != nil {
t.Fatal(err)
}
want := []string{
"vpc vp-s7: route 10.241.1.13/32 exported in vrf-s7 without a running owner: its traffic is black-holed",
"vpc vp-s7: route 10.241.1.50/32 exported in vrf-s7 without a running owner: its traffic is black-holed",
"vpc vp-s7: route 10.241.1.11/32 not exported in vrf-s7",
}
if got := notified(r); !reflect.DeepEqual(got, want) {
t.Errorf("notifications :\n%q\nattendu :\n%q", got, want)
}
}
func TestCheckL3VPCsChecksInterfacesAndTheL3VNI(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-down", state.Error)
seedKV(t, db, "vpc/vp-down/cidr", "10.243.0.0/16")
seedKV(t, db, "vpc/vp-down/l3vni", "2800")
p := &fakeProbe{
vni: map[uint32]frr.VNIState{2700: {Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:99"}},
links: map[string]string{"/vxl3-s7": "interface vxl3-s7 down", "vp-s7/l3-s7-i": "interface l3-s7-i not found (in netns)"},
}
r := &recorder{}
if err := CheckL3VPCs(db, bgpCfg(), p, r); err != nil {
t.Fatal(err)
}
want := []string{
"vpc vp-s7: interface vxl3-s7 down",
"vpc vp-s7: interface l3-s7-i not found (in netns)",
`vpc vp-s7: l3vni 2700 has router mac "02:02:c0:a8:0e:99" in frr, expected 02:02:c0:a8:0e:0b`,
}
if got := notified(r); !reflect.DeepEqual(got, want) {
t.Errorf("notifications :\n%q\nattendu :\n%q", got, want)
}
p.vni[2700] = frr.VNIState{Type: "L2", State: "Up"}
p.links = nil
r = &recorder{}
CheckL3VPCs(db, bgpCfg(), p, r)
if !r.hasProblemContaining(`l3vni 2700 is type "L2" state "Up" in frr, expected L3 Up`) {
t.Errorf("notifications %q", notified(r))
}
p.vni[2700] = frr.VNIState{Type: "L3", State: "Down", RouterMAC: "02:02:c0:a8:0e:0b"}
r = &recorder{}
CheckL3VPCs(db, bgpCfg(), p, r)
if !r.hasProblemContaining(`l3vni 2700 is type "L3" state "Down" in frr, expected L3 Up`) {
t.Errorf("notifications %q", notified(r))
}
delete(p.vni, 2700)
r = &recorder{}
CheckL3VPCs(db, bgpCfg(), p, r)
if !r.hasProblemContaining("l3vni 2700 unreadable in frr") {
t.Errorf("notifications %q", notified(r))
}
}
func TestCheckL3VPCsReportsAnL3VNIWithoutBGP(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")
r := &recorder{}
CheckL3VPCs(db, &configuration.Config{}, &fakeProbe{}, r)
want := []string{"vpc vp-s7: vpc has an l3vni but the agent configuration has no bgp section"}
if got := notified(r); !reflect.DeepEqual(got, want) {
t.Errorf("notifications %q, attendu %q", got, want)
}
}
func TestCheckL3VPCsReportsUnreadableRoutesAndVTEP(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.routesErr = errors.New("netlink refused")
p.vtepErr = errors.New("no address")
r := &recorder{}
CheckL3VPCs(db, bgpCfg(), p, r)
if n := len(r.forName("vtep")); n != 1 {
t.Errorf("VTEP illisible signalé %d fois, attendu une fois par passage : %q", n, notified(r))
}
if !r.hasProblemContaining("routes of vrf-s7 unreadable: netlink refused") || !r.hasProblemContaining("vtep address unreadable on br-000000") {
t.Errorf("notifications %q", notified(r))
}
if r.hasProblemContaining("router mac") {
t.Errorf("RMAC comparée sans VTEP : %q", notified(r))
}
}

View file

@ -6,6 +6,7 @@ import (
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/frr"
"git.g3e.fr/syonad/two/internal/watchdog/notify"
"git.g3e.fr/syonad/two/pkg/systemd"
@ -21,6 +22,7 @@ type Watchdog struct {
logger *slog.Logger
interval time.Duration
dbusDown bool
l3 l3Probe
}
func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *slog.Logger, interval time.Duration) *Watchdog {
@ -38,6 +40,7 @@ func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *sl
notifier: n,
logger: logger,
interval: interval,
l3: systemProbe{frr: frr.NewClient()},
}
}
@ -71,6 +74,10 @@ 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)
}
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)
}
}
func (w *Watchdog) units() (unitChecker, func()) {

View file

@ -1,6 +1,7 @@
# Bael
Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet.
Serveur DHCP intégré, en coexistence avec dnsmasq ; routage inter-subnet entre hyperviseurs par
L3VNI, avec une configuration BGP pilotée par l'agent ; documentation du projet.
## Fonctionnalités
@ -31,8 +32,45 @@ Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet.
subnet déjà créé reste servi par le serveur qui l'a été. La procédure est documentée
- Toute valeur autre que `dnsmasq` ou `two` fait échouer le démarrage de l'agent
**Routage inter-subnet entre hyperviseurs : L3VNI (#41)**
- Nouveau champ facultatif `l3vni` sur `POST /vpcs` (1 à 65535, sauf 253-255 : c'est aussi
l'identifiant de la table de routage, et le numéro du RD `<VTEP>:<l3vni>`, sur 16 bits).
Absent, le VPC se comporte comme avant. Une L3VNI déjà portée par un VPC de l'agent est refusée
(409), comme un `l3vni` demandé sans section `bgp`
- Pour un VPC routé, l'agent pose sur l'hyperviseur une VRF (table = L3VNI), un bridge à la MAC de
routeur `02:02:<IPv4 du VTEP>`, le VXLAN de la L3VNI, un lien de transit `169.254.0.1/30` ↔
`169.254.0.2/30` vers le netns et la route du `cidr` du VPC dans le netns ; FRR reçoit la VRF,
sa `vni`, une instance `router bgp … vrf` (RD `<VTEP>:<l3vni>`, RT `<asn>:<l3vni>`) et l'export
des routes du `cidr`. Un hyperviseur n'a plus besoin de porter un subnet pour joindre ses VM
- Routes annoncées : le `/24` de chaque subnet `vxlan` à sa création, le `/32` de chaque interface
de VM juste avant son passage en `running` ; retirés en premier à la suppression
- La suppression d'un VPC routé retire la configuration de routage de FRR, puis les interfaces,
puis la VRF de FRR — dans cet ordre, faute de quoi `bgpd` plante (FRR 10.7.1)
**Configuration BGP pilotée par l'agent**
- Nouvelle section facultative `bgp` (`asn`, `route_reflectors`). Présente, l'agent applique à
chaque démarrage, par `vtysh`, la base BGP de l'hyperviseur (router-id = VTEP, peer-group
`fabric` vers les route reflectors, EVPN, `advertise-all-vni`) et l'enregistre :
`/etc/frr/frr.conf` devient un fichier généré. Un route reflector retiré de la liste est retiré
de FRR. Absente, l'agent ne touche pas à FRR
- Le démarrage échoue si la section est incomplète, si FRR tourne déjà sous un autre AS ou si
`vtysh` ne répond pas
**Gateway des subnets `vxlan`**
- Le bridge du subnet porte une **MAC propre à l'hôte**, `02:03:<IPv4 du VTEP>`, posée à la
création du subnet. Une MAC identique sur tous les hôtes (anycast) a été essayée puis retirée :
annoncée en double en EVPN, elle empêchait aussi une gateway de joindre en L2 une VM d'un autre
hôte (#57)
**Exploitation**
- Le watchdog contrôle aussi, avec une section `bgp` : les sessions vers les route reflectors ;
pour chaque VPC routé, les interfaces de la VRF et l'état de la L3VNI dans FRR (type, état, MAC
de routeur) ; la cohérence entre routes exportées et ressources `running` — une route exportée
sans propriétaire est signalée comme **trou noir**, une route attendue absente comme manquante
- Le watchdog interroge le serveur DHCP intégré et compare les réservations servies à celles que
la base implique. Il nomme ce qui diverge — ordre perdu à la création, ordre perdu à la
suppression, adresse ou route par défaut divergente — et reste en lecture seule
@ -42,6 +80,9 @@ Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet.
## Correctifs
- **Suppression d'un subnet refusée tant qu'une VM non supprimée l'utilise** (409, avec la liste
des VM), pour tous les subnets : garantit qu'une route `/32` est retirée avant le `/24` de son
subnet, ce qui évite un trou noir partiel mesuré en lab
- **Un fichier de configuration présent mais invalide fait désormais échouer le démarrage.**
Jusqu'en 0.1.0 l'erreur de lecture était ignorée : l'agent tournait alors entièrement sur ses
valeurs par défaut sans le dire, ce qui rendait indétectable une simple tabulation d'indentation
@ -50,6 +91,11 @@ Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet.
## Changements internes
- Nouveaux paquets `internal/frr` (seul point d'appel à `vtysh` : génération des commandes,
démontage ordonné, relecture de la configuration après démontage) et `internal/sysctl` ; une
remarque de `vtysh` (« Configuration applied with notes ») n'est pas une erreur, et la
suppression d'une instance BGP de VRF est réessayée tant que `bgpd` n'a pas libéré la L3VNI
- Les tests du dispatcher arrêtent les workers avant de fermer la base (#47)
- Le module passe à **Go 1.25**, exigé par la bibliothèque DHCP retenue. La version de Go du
workflow de build, restée à 1.21 alors que le module en demandait davantage, est alignée
- Nouveau paquet `pkg/db/statefile` : persistance générique d'un état de composant dans un
@ -63,6 +109,14 @@ Serveur DHCP intégré, en coexistence avec dnsmasq, et documentation du projet.
Celles de la 0.1.0 restent valables, sauf mention contraire ci-dessus. S'y ajoutent :
- **L3VNI** : pas de migration à chaud ; le cache ARP d'une VM qui changerait d'hôte reste à
traiter (#57). MTU 1500 de bout en bout (#56). Un seul route reflector qualifié (#54). Le
transit `169.254.0.0/30` étant identique sur tous les hôtes, les ICMP des sauts distants sont
rejetés comme « martiens » (traceroute partiel)
- Avec une section `bgp`, l'agent ne démarre pas sans FRR et `agent.service` ne le relance pas :
au démarrage, l'ordre est migration réseau, puis FRR, puis l'agent (#52)
- `bootstrap_kvm.sh` active `net.ipv4.ip_forward` en global ; le forwarding que l'agent active
sur les seules interfaces de la VRF n'en restreint donc pas la portée
- **dnsmasq n'est pas retiré** et reste un paquet requis : le backend intégré ne sert que les
subnets créés après la bascule, et le retour arrière suppose dnsmasq installé
- Pas de DNS, pas de pool dynamique, pas de PXE, pas de DHCPv6 dans le serveur intégré
@ -82,6 +136,11 @@ curl -O https://git.g3e.fr/syonad/two/raw/branch/main/scripts/deploy.sh
bash ./deploy.sh -t 0.2.0
```
Aucune action n'est requise : sans `dhcp.backend` dans `/etc/two/agent.yml`, le comportement est
celui de la 0.1.0. Pour passer au serveur intégré, suivre la procédure de bascule dans la
Aucune action n'est requise : sans `dhcp.backend` ni `bgp` dans `/etc/two/agent.yml`, le
comportement est celui de la 0.1.0, à une exception près — **un subnet encore utilisé par une VM
ne se supprime plus** : supprimer les VM d'abord. Les subnets `vxlan` existants gardent leur MAC
de gateway jusqu'à leur recréation.
Pour router entre hyperviseurs : ajouter la section `bgp`, réduire `frr.conf` à `hostname` et
`log` (l'agent pose le reste), puis créer les VPC avec `l3vni`. Pour passer au serveur intégré, suivre la procédure de bascule dans la
documentation d'exploitation — elle suppose un hyperviseur vidé.

View file

@ -2,7 +2,8 @@
API_URL="${SCW_API_URL:-https://api.scaleway.com}"
CREDENTIALS_FILE="${LAB_CREDENTIALS_FILE:-${HOME}/.config/two-lab/scaleway.env}"
OFFER_NAME="${LAB_OFFER:-EM-B212X-SSD}"
OFFER_NAME="${LAB_OFFER:-EM-B420E-NVME}"
ALL_ZONES="fr-par-1 fr-par-2 nl-ams-1 nl-ams-2 pl-waw-2 pl-waw-3"
OS_NAME="${LAB_OS_NAME:-Debian}"
OS_VERSION="${LAB_OS_VERSION:-12}"
LAB_NAME="${LAB_NAME:-two-lab}"
@ -30,20 +31,21 @@ usage: ${0##*/} <commande> [arguments]
et le prix ; ne crée rien
up crée le serveur de lab, attend la fin de son installation et son SSH,
puis le prépare (voir prepare)
status liste les serveurs de lab du projet
status liste les serveurs de lab du projet, dans toutes les zones candidates
ssh [commande] se connecte au serveur de lab ; avec une commande, un terminal n'est demandé
que si l'entrée standard en est un
prepare installe sur le serveur ce dont lab a besoin (qemu, genisoimage), vérifie
/dev/kvm et la virtualisation imbriquée ; lancé aussi par up
/dev/kvm, la virtualisation imbriquée et un CPU x86-64-v3 ; lancé aussi par up
push <topologie> compile cmd/lab pour linux/amd64 et dépose sur le serveur ~/lab et le
répertoire de la topologie dans ~/topology/ (avec les fichiers qu'elle
référence) ; ensuite : ssh './lab up topology/<topologie>'
down supprime tous les serveurs de lab du projet et attend leur disparition
down supprime tous les serveurs de lab du projet, dans toutes les zones candidates,
et attend leur disparition
session [cmd] up, puis la commande distante (ou un shell), puis down quoi qu'il arrive
environnement : SCW_SECRET_KEY et SCW_DEFAULT_PROJECT_ID (requis, à défaut lus dans ${CREDENTIALS_FILE},
fichier en 0600, lignes CLÉ=valeur), SCW_DEFAULT_ZONE (${ZONE}),
LAB_OFFER (${OFFER_NAME}), LAB_OS_NAME (${OS_NAME}), LAB_OS_VERSION (${OS_VERSION}),
fichier en 0600, lignes CLÉ=valeur), LAB_ZONES (zones candidates, dans l'ordre :
${ZONES} ; SCW_DEFAULT_ZONE passe en tête), LAB_OFFER (${OFFER_NAME}), LAB_OS_NAME (${OS_NAME}), LAB_OS_VERSION (${OS_VERSION}),
LAB_SSH_KEY (${SSH_KEY} ; à défaut, l'agent SSH)
ne jamais lancer sous 'bash -x' : la trace afficherait SCW_SECRET_KEY.
@ -64,10 +66,19 @@ load_credentials () {
esac
done < "${CREDENTIALS_FILE}"
fi
ZONE="${SCW_DEFAULT_ZONE:-fr-par-1}"
ZONES=$(candidate_zones "${SCW_DEFAULT_ZONE:-}" "${LAB_ZONES:-${ALL_ZONES}}")
ZONE="${ZONES%% *}"
PROJECT_ID="${SCW_DEFAULT_PROJECT_ID:-}"
}
candidate_zones () {
local PREFERRED="${1}" LIST="${2}" Z OUT="${1}"
for Z in ${LIST}; do
[[ " ${OUT} " == *" ${Z} "* ]] || OUT="${OUT:+${OUT} }${Z}"
done
printf '%s\n' "${OUT}"
}
require_env () {
[[ -n "${SCW_SECRET_KEY:-}" ]] || die "SCW_SECRET_KEY absent de l'environnement"
[[ -n "${PROJECT_ID}" ]] || die "SCW_DEFAULT_PROJECT_ID absent de l'environnement"
@ -124,7 +135,7 @@ resolve_offer () {
[[ $(jq -r '.stock' <<< "${OFFER}") != "empty" ]] || die "offre ${OFFER_NAME} en rupture de stock en ${ZONE}"
[[ $(jq -r '((.fee.units // 0) == 0) and ((.fee.nanos // 0) == 0)' <<< "${OFFER}") == "true" ]] \
|| die "offre ${OFFER_NAME} : frais de mise en service non nuls ($(money '.fee' <<< "${OFFER}")), refus"
printf '%s\n' "${OFFER}"
jq -c --arg z "${ZONE}" '. + {zone: $z}' <<< "${OFFER}"
}
resolve_os () {
@ -164,11 +175,18 @@ build_request () {
}
lab_servers () {
local JSON
JSON=$(api GET "/baremetal/v1/zones/${ZONE}/servers?project_id=${PROJECT_ID}&tags=${LAB_TAG}&page_size=100") \
|| return 1
jq -c --arg p "${PROJECT_ID}" --arg t "${LAB_TAG}" \
'[.servers[] | select(.project_id == $p and (.tags | index($t)))]' <<< "${JSON}"
local JSON Z ALL="[]" RC=0
for Z in ${ZONES}; do
if ! JSON=$(api GET "/baremetal/v1/zones/${Z}/servers?project_id=${PROJECT_ID}&tags=${LAB_TAG}&page_size=100"); then
warn "zone ${Z} : liste des serveurs de lab indisponible"
RC=1
continue
fi
ALL=$(jq -c --argjson all "${ALL}" --arg p "${PROJECT_ID}" --arg t "${LAB_TAG}" --arg z "${Z}" \
'$all + [.servers[] | select(.project_id == $p and (.tags | index($t))) | . + {zone: $z}]' <<< "${JSON}")
done
printf '%s\n' "${ALL}"
return "${RC}"
}
server_ip () {
@ -180,12 +198,26 @@ server_is_installing () {
or (.install.status // "") == "to_install" or (.install.status // "") == "installing"' >/dev/null
}
select_zone () {
local Z OUT
for Z in ${ZONES}; do
if OUT=$(ZONE="${Z}" resolve_offer 2>&1); then
printf '%s\n' "${OUT}"
return 0
fi
warn "${Z} : ${OUT##*!! }"
done
die "offre horaire ${OFFER_NAME} disponible dans aucune zone candidate (${ZONES})"
}
cmd_plan () {
local OFFER OS KEYS
OFFER=$(resolve_offer) || exit 1
OFFER=$(select_zone) || exit 1
ZONE=$(jq -r '.zone' <<< "${OFFER}")
OS=$(resolve_os "$(jq -r '.id' <<< "${OFFER}")") || exit 1
KEYS=$(resolve_ssh_keys) || exit 1
info "offre : ${OFFER_NAME} ($(jq -r '.id' <<< "${OFFER}")), facturation $(jq -r '.subscription_period' <<< "${OFFER}"), stock $(jq -r '.stock' <<< "${OFFER}")"
info "zone : ${ZONE}"
info "offre : ${OFFER_NAME} ($(jq -r '.id' <<< "${OFFER}")), $(jq -r '[.cpus[]?.name] | unique | join(", ") | if . == "" then "CPU ?" else . end' <<< "${OFFER}"), facturation $(jq -r '.subscription_period' <<< "${OFFER}"), stock $(jq -r '.stock' <<< "${OFFER}")"
info "prix : $(money '.price_per_hour' <<< "${OFFER}") HT par heure, frais de mise en service $(money '.fee' <<< "${OFFER}")"
info "os : $(jq -r '"\(.name) \(.version) (\(.id))"' <<< "${OS}"), utilisateur $(jq -r '.user.default_value // "?"' <<< "${OS}")"
info "clés : $(jq -r 'length' <<< "${KEYS}") clé(s) SSH du projet"
@ -251,7 +283,8 @@ require_no_lab_server () {
report_uncertain_creation () {
local FOUND
if FOUND=$(lab_servers) && [[ $(jq 'length' <<< "${FOUND}") -gt 0 ]]; then
FOUND=$(lab_servers)
if [[ $(jq 'length' <<< "${FOUND}") -gt 0 ]]; then
warn "un serveur de lab existe bien : $(jq -r '[.[].id] | join(", ")' <<< "${FOUND}")"
fi
die "création incertaine : le serveur a pu être créé et être facturé ; '${0##*/} status' puis '${0##*/} down'"
@ -260,15 +293,16 @@ report_uncertain_creation () {
cmd_up () {
local OFFER OS KEYS BODY JSON ID IP SSH_USER
require_no_lab_server
OFFER=$(resolve_offer) || exit 1
OFFER=$(select_zone) || exit 1
ZONE=$(jq -r '.zone' <<< "${OFFER}")
OS=$(resolve_os "$(jq -r '.id' <<< "${OFFER}")") || exit 1
KEYS=$(resolve_ssh_keys) || exit 1
BODY=$(build_request "${OFFER}" "${OS}" "${KEYS}")
info "création de ${LAB_NAME} (${OFFER_NAME}, $(money '.price_per_hour' <<< "${OFFER}")/h HT)"
info "création de ${LAB_NAME} (${OFFER_NAME}, ${ZONE}, $(money '.price_per_hour' <<< "${OFFER}")/h HT)"
JSON=$(api POST "/baremetal/v1/zones/${ZONE}/servers" "${BODY}") || report_uncertain_creation
ID=$(jq -r '.id // empty' <<< "${JSON}" 2>/dev/null)
[[ -n "${ID}" ]] || report_uncertain_creation
CREATED_ID="${ID}"
CREATED_ID="${ZONE} ${ID}"
info "serveur ${ID} créé, facturé jusqu'à '${0##*/} down'"
JSON=$(wait_installed "${ID}") || die "serveur ${ID} inutilisable — il est toujours facturé : '${0##*/} down'"
IP=$(server_ip <<< "${JSON}")
@ -283,13 +317,14 @@ cmd_up () {
}
cmd_status () {
local SERVERS
SERVERS=$(lab_servers) || die "impossible de lister les serveurs de lab"
local SERVERS RC=0
SERVERS=$(lab_servers) || RC=1
if [[ $(jq 'length' <<< "${SERVERS}") -eq 0 ]]; then
info "aucun serveur de lab dans le projet ${PROJECT_ID} (${ZONE})"
return 0
[[ "${RC}" -eq 0 ]] && info "aucun serveur de lab dans le projet ${PROJECT_ID} (${ZONES})"
else
jq -r '.[] | "\(.zone) \(.id) \(.name) \(.offer_name) \(.status) installation \(.install.status // "none") \(.created_at) \([.ips[] | select(.version == "IPv4") | .address] | join(","))"' <<< "${SERVERS}"
fi
jq -r '.[] | "\(.id) \(.name) \(.offer_name) \(.status) installation \(.install.status // "none") \(.created_at) \([.ips[] | select(.version == "IPv4") | .address] | join(","))"' <<< "${SERVERS}"
[[ "${RC}" -eq 0 ]] || die "liste incomplète : des serveurs de lab peuvent exister dans les zones en erreur"
}
require_known_server () {
@ -319,13 +354,18 @@ case "${NESTED}" in
Y|1) ;;
*) echo "virtualisation imbriquée désactivée (nested=${NESTED:-absent})" >&2; exit 1 ;;
esac
echo "qemu $(qemu-system-x86_64 --version | head -n 1), nested=${NESTED}"
LD=$(ls /lib64/ld-linux-x86-64.so.2 /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 2>/dev/null | head -n 1)
if ! "${LD}" --help 2>/dev/null | grep -q 'x86-64-v3 (supported'; then
echo "CPU sans x86-64-v3 :$(grep -m 1 'model name' /proc/cpuinfo | cut -d: -f2) — Rocky 10 / RHEL 10 n'y démarrent pas" >&2
exit 1
fi
echo "qemu $(qemu-system-x86_64 --version | head -n 1), nested=${NESTED},$(grep -m 1 'model name' /proc/cpuinfo | cut -d: -f2)"
EOF
}
cmd_prepare () {
require_known_server
info "préparation du serveur : qemu, genisoimage, KVM imbriqué"
info "préparation du serveur : qemu, genisoimage, KVM imbriqué, CPU x86-64-v3"
prepare_script | ssh_run -- bash -s
}
@ -390,28 +430,29 @@ wait_gone () {
lab_server_ids () {
local DEADLINE=$(( SECONDS + DELETE_TIMEOUT ))
local SERVERS
local SERVERS="[]"
while (( SECONDS < DEADLINE )); do
if SERVERS=$(lab_servers); then
jq -r '.[].id' <<< "${SERVERS}"
jq -r '.[] | "\(.zone) \(.id)"' <<< "${SERVERS}"
return 0
fi
warn "liste des serveurs de lab indisponible, nouvel essai dans ${POLL_INTERVAL}s"
warn "liste des serveurs de lab incomplète, nouvel essai dans ${POLL_INTERVAL}s"
sleep "${POLL_INTERVAL}"
done
jq -r '.[] | "\(.zone) \(.id)"' <<< "${SERVERS}"
return 1
}
cmd_down () {
local IDS ID FAILED=0
if ! IDS=$(lab_server_ids); then
warn "impossible de lister les serveurs de lab après ${DELETE_TIMEOUT}s"
warn "liste des serveurs de lab incomplète après ${DELETE_TIMEOUT}s : suppression de ceux qui sont listés"
FAILED=1
IDS=""
fi
IDS=$(printf '%s\n%s\n' "${IDS}" "${CREATED_ID}" | grep -v '^$' | sort -u)
for ID in ${IDS}; do
info "suppression de ${ID}"
while read -r ZONE ID; do
[[ -n "${ID}" ]] || continue
info "suppression de ${ID} (${ZONE})"
if ! delete_server "${ID}"; then
warn "suppression de ${ID} toujours refusée"
FAILED=1
@ -421,7 +462,7 @@ cmd_down () {
warn "${ID} toujours présent après ${DELETE_TIMEOUT}s"
FAILED=1
fi
done
done <<< "${IDS}"
rm -f "${STATE_DIR}/ip" "${STATE_DIR}/user" "${STATE_DIR}/known_hosts"
[[ "${FAILED}" -eq 0 ]] || die "SERVEUR(S) DE LAB TOUJOURS FACTURÉ(S) — '${0##*/} status', puis la console Scaleway"
info "aucun serveur de lab ne reste dans le projet"

View file

@ -63,18 +63,22 @@ with open(os.path.join(d, "calls.log"), "a") as f:
if "X-Auth-Token: " + os.environ["FAKE_SECRET"] not in headers:
reply(401, {"message": "unauthorized"})
zone = "/baremetal/v1/zones/fr-par-1"
zname = path.split("/")[4] if path.startswith("/baremetal/v1/zones/") else ""
zone = "/baremetal/v1/zones/" + zname
if method == "GET" and path == zone + "/offers":
reply(200, {"offers": st["offers"], "total_count": len(st["offers"])})
offers = st.get("zones", {}).get(zname, {}).get("offers", st["offers"] if zname == "fr-par-1" else [])
reply(200, {"offers": offers, "total_count": len(offers)})
if method == "GET" and path == zone + "/os":
reply(200, {"os": st["os"], "total_count": len(st["os"])})
if method == "GET" and path == "/iam/v1alpha1/ssh-keys":
reply(200, {"ssh_keys": st["keys"], "total_count": len(st["keys"])})
if method == "GET" and path == zone + "/servers":
if st.get("zones", {}).get(zname, {}).get("list_fail"):
reply(503, {"message": "service unavailable"})
if st["list_errors"] > 0:
st["list_errors"] -= 1
reply(503, {"message": "service unavailable"})
listed = [v for v in st["servers"].values() if not v.get("hidden")]
listed = [v for v in st["servers"].values() if not v.get("hidden") and v.get("zone", "fr-par-1") == zname]
reply(200, {"servers": listed, "total_count": len(listed)})
if method == "POST" and path == zone + "/servers":
req = json.loads(body)
@ -84,7 +88,7 @@ if method == "POST" and path == zone + "/servers":
sid = "srv-%d" % st["seq"]
st["servers"][sid] = {"id": sid, "name": req["name"], "project_id": req["project_id"],
"tags": req["tags"], "offer_name": "EM-B212X-SSD", "status": "delivering",
"install": {"status": "to_install"}, "ips": [], "created_at": "now",
"install": {"status": "to_install"}, "ips": [], "created_at": "now", "zone": zname,
"hidden": st["hide_from_list"]}
if st["post_fail_after_create"]:
reply(502, {"message": "bad gateway"})
@ -93,7 +97,7 @@ if method == "POST" and path == zone + "/servers":
reply(200, st["servers"][sid])
if path.startswith(zone + "/servers/"):
sid = path.rsplit("/", 1)[1]
if sid not in st["servers"]:
if sid not in st["servers"] or st["servers"][sid].get("zone", "fr-par-1") != zname:
reply(404, {"message": "not found"})
srv = st["servers"][sid]
if method == "GET" and st["get_errors"] > 0:
@ -222,7 +226,8 @@ lab_env () {
SCW_API_URL="https://api.example.invalid" SCW_SECRET_KEY="${SECRET}" \
SCW_DEFAULT_PROJECT_ID="${PROJECT}" LAB_POLL_INTERVAL="${LAB_POLL_INTERVAL:-0}" \
LAB_INSTALL_TIMEOUT="${LAB_INSTALL_TIMEOUT:-60}" LAB_DELETE_TIMEOUT="${LAB_DELETE_TIMEOUT:-60}" \
LAB_SSH_TIMEOUT="${LAB_SSH_TIMEOUT:-60}" \
LAB_SSH_TIMEOUT="${LAB_SSH_TIMEOUT:-60}" LAB_ZONES="${LAB_ZONES:-fr-par-1}" \
LAB_OFFER="${LAB_OFFER:-EM-B212X-SSD}" ${SCW_DEFAULT_ZONE:+SCW_DEFAULT_ZONE="${SCW_DEFAULT_ZONE}"} \
"$@"
}
@ -467,6 +472,33 @@ test_down_fails_loudly_when_listing_never_works () {
teardown
}
test_down_deletes_what_answering_zones_list_when_one_zone_fails () {
setup "down : une zone en erreur n'empêche pas de supprimer les serveurs des autres"
mutate ".servers[\"srv-lab\"] = ${LAB_SERVER} | .zones = {\"nl-ams-2\": {list_fail: true}}"
LAB_ZONES="fr-par-1 nl-ams-2" LAB_DELETE_TIMEOUT=1 run_lab down && fail "down a réussi malgré une zone en erreur"
[[ $(remaining) == "foreign-1,foreign-2" ]] || fail "restants : $(remaining)"
grep -q "zone nl-ams-2" "${WORK}/out.log" || fail "zone en erreur non signalée"
grep -q "TOUJOURS FACTURÉ" "${WORK}/out.log" || fail "pas d'alerte de facturation"
teardown
}
test_status_lists_answering_zones_and_fails_when_one_zone_fails () {
setup "status : liste les zones qui répondent, échoue si une zone est en erreur"
mutate ".servers[\"srv-lab\"] = ${LAB_SERVER} | .zones = {\"nl-ams-2\": {list_fail: true}}"
LAB_ZONES="fr-par-1 nl-ams-2" run_lab status && fail "status a réussi malgré une zone en erreur"
grep -q "^fr-par-1 srv-lab " "${WORK}/out.log" || fail "srv-lab non listé"
grep -q "liste incomplète" "${WORK}/out.log" || fail "liste incomplète non signalée"
teardown
}
test_up_refuses_when_one_zone_cannot_be_listed () {
setup "up : refus si une zone ne peut pas être listée"
mutate '.zones = {"nl-ams-2": {list_fail: true}} | .progress = [["ready","completed"]]'
LAB_ZONES="fr-par-1 nl-ams-2" run_lab up && fail "up a réussi"
grep -q "^POST" "${WORK}/calls.log" && fail "serveur créé sans connaître toutes les zones"
teardown
}
test_session_deletes_created_server_even_if_missing_from_list () {
setup "session : supprime le serveur créé même absent de la liste"
mutate '.hide_from_list = true | .progress = [["ready","completed"]]'
@ -730,7 +762,7 @@ test_ssh_without_terminal_does_not_ask_for_one () {
run_lab_without_env_credentials () {
env -i PATH="${WORK}/bin:${PATH}" HOME="${WORK}" TMPDIR="${TMPDIR:-/tmp}" \
FAKE_DIR="${WORK}" FAKE_SECRET="${SECRET}" SCW_API_URL="https://api.example.invalid" \
LAB_POLL_INTERVAL=0 "$@" bash "${SCRIPT}" plan > "${WORK}/out.log" 2>&1
LAB_POLL_INTERVAL=0 LAB_ZONES=fr-par-1 LAB_OFFER=EM-B212X-SSD "$@" bash "${SCRIPT}" plan > "${WORK}/out.log" 2>&1
}
write_credentials () {
@ -814,6 +846,74 @@ signal_during_session () {
teardown
}
zone_offer () {
jq -n --arg id "${1}" --arg stock "${2}" '{id: $id, name: "EM-B420E-NVME", subscription_period: "hourly", enable: true,
stock: $stock, cpus: [{name: "AMD EPYC 7272"}], price_per_hour: {currency_code: "EUR", units: 0, nanos: 444000000},
fee: {currency_code: "EUR", units: 0, nanos: 0}}'
}
test_default_offer_is_the_epyc_one () {
setup "offre par défaut : EM-B420E-NVME"
LAB_OFFER=EM-B420E-NVME run_lab plan
grep -q 'aucune zone candidate' "${WORK}/out.log" || fail "l'offre EM-B420E-NVME n'a pas été cherchée"
grep -q 'name=EM-B420E-NVME' "${WORK}/calls.log" || fail "requête : $(cat "${WORK}/calls.log")"
[[ $(env -i bash -c ". '${SCRIPT}'; echo \${OFFER_NAME}") == EM-B420E-NVME ]] \
|| fail "défaut lu : $(env -i bash -c ". '${SCRIPT}'; echo \${OFFER_NAME}")"
teardown
}
test_up_takes_the_first_zone_with_stock () {
setup "up : première zone candidate où l'offre est en stock"
mutate ".zones = {\"fr-par-2\": {offers: [$(zone_offer off-par2 empty)]}, \"nl-ams-2\": {offers: [$(zone_offer off-ams2 available)]}}
| .progress = [[\"ready\", \"completed\"]]"
LAB_ZONES="fr-par-2 nl-ams-2 pl-waw-3" LAB_OFFER=EM-B420E-NVME run_lab up
grep -q 'POST /baremetal/v1/zones/nl-ams-2/servers' "${WORK}/calls.log" || fail "pas de création en nl-ams-2 : $(grep POST "${WORK}/calls.log")"
grep -q 'zones/pl-waw-3/offers' "${WORK}/calls.log" && fail "zone suivante interrogée après avoir trouvé du stock"
[[ $(jq -r '.offer_id' "${WORK}/create.json") == off-ams2 ]] || fail "offre créée : $(jq -c . "${WORK}/create.json")"
grep -q 'fr-par-2 : offre EM-B420E-NVME en rupture de stock' "${WORK}/out.log" || fail "raison du refus de fr-par-2 absente"
teardown
}
test_preferred_zone_goes_first () {
setup "SCW_DEFAULT_ZONE : préférence placée en tête, sans exclure les autres"
[[ $(lab_env bash -c ". '${SCRIPT}'; candidate_zones nl-ams-2 'fr-par-1 nl-ams-2 pl-waw-3'") == "nl-ams-2 fr-par-1 pl-waw-3" ]] \
|| fail "ordre : $(lab_env bash -c ". '${SCRIPT}'; candidate_zones nl-ams-2 'fr-par-1 nl-ams-2 pl-waw-3'")"
[[ $(lab_env bash -c ". '${SCRIPT}'; candidate_zones '' 'fr-par-1 nl-ams-2'") == "fr-par-1 nl-ams-2" ]] || fail "sans préférence"
teardown
}
test_no_zone_with_stock_is_refused_without_creation () {
setup "aucune zone en stock : refus, rien n'est créé"
LAB_ZONES="fr-par-2 nl-ams-2" LAB_OFFER=EM-B420E-NVME run_lab up && fail "code de retour nul"
grep -q 'disponible dans aucune zone candidate (fr-par-2 nl-ams-2)' "${WORK}/out.log" || fail "message absent"
grep -q '^POST' "${WORK}/calls.log" && fail "serveur créé"
teardown
}
test_down_and_status_cover_every_candidate_zone () {
setup "down et status : serveurs de lab de toutes les zones candidates"
mutate ".servers[\"lab-ams\"] = {id: \"lab-ams\", name: \"two-lab\", project_id: \"${PROJECT}\", tags: [\"two-lab\"],
status: \"ready\", install: {status: \"completed\"}, ips: [], zone: \"nl-ams-2\", offer_name: \"EM-B420E-NVME\", created_at: \"now\"}"
mutate ".servers[\"lab-par\"] = {id: \"lab-par\", name: \"two-lab\", project_id: \"${PROJECT}\", tags: [\"two-lab\"],
status: \"ready\", install: {status: \"completed\"}, ips: [], offer_name: \"EM-B212X-SSD\", created_at: \"now\"}"
LAB_ZONES="fr-par-1 nl-ams-2" run_lab status
grep -q '^nl-ams-2 lab-ams' "${WORK}/out.log" || fail "status : $(cat "${WORK}/out.log")"
LAB_ZONES="fr-par-1 nl-ams-2" run_lab down || fail "down en échec"
grep -q 'DELETE /baremetal/v1/zones/nl-ams-2/servers/lab-ams' "${WORK}/calls.log" || fail "lab-ams non supprimé dans sa zone"
[[ $(remaining) == "foreign-1,foreign-2" ]] || fail "restants : $(remaining)"
teardown
}
test_prepare_script_requires_x86_64_v3 () {
setup "prepare : refus d'un CPU sans x86-64-v3"
local DIR="${WORK}/root"
mkdir -p "${DIR}/bin" "${DIR}/sys/module/kvm_intel/parameters" "${DIR}/dev"
lab_env bash -c ". '${SCRIPT}'; prepare_script" > "${WORK}/prepare.sh"
grep -q "x86-64-v3 (supported" "${WORK}/prepare.sh" || fail "aucune vérification x86-64-v3 dans le script de préparation"
grep -q "exit 1" <<< "$(sed -n '/x86-64-v3/,/fi/p' "${WORK}/prepare.sh")" || fail "pas d'arrêt si le niveau manque"
teardown
}
test_session_handles_term () { signal_during_session TERM 143; }
test_session_handles_hup () { signal_during_session HUP 129; }
test_session_handles_int () { signal_during_session INT 130; }

View file

@ -26,6 +26,10 @@ api_delete () {
curl -fsS -o /dev/null -X DELETE "${API}/${1}"
}
api_code () {
curl -s -o /dev/null -w '%{http_code}' -X "${1}" "${API}/${2}"
}
api_state () {
curl -fsS "${API}/${1}" 2>/dev/null | jq -r .state
}
@ -44,8 +48,9 @@ wait_state () {
}
vpc_create () {
local l3vni="${3:+,\"l3vni\":${3}}"
api_state "vpcs/${1}" | grep -qx running && return 0
api_post vpcs "{\"name\":\"${1}\",\"cidr\":\"${2}\"}" && wait_state "vpcs/${1}" running
api_post vpcs "{\"name\":\"${1}\",\"cidr\":\"${2}\"${l3vni}}" && wait_state "vpcs/${1}" running
}
subnet_create () {
@ -83,6 +88,7 @@ vm_key () {
vm_create () {
local name="${1}" subnet="${2}" ip="${3}" key="${4:-}" meta="{}"
api_state "vms/${name}" | grep -qx running && return 0
[ -n "${key}" ] && meta="{\"sshkey\":\"${key}\"}"
mkdir -p "${VOLUMES}"
cp "${TWO_IMAGE}" "${VOLUMES}/${name}.qcow2" || return 1
@ -149,3 +155,105 @@ state = json.loads(buf).get("state") or {}
print(" ".join(sorted(h["mac"].lower() + "=" + h["ip"] for h in state.get("hosts") or [])))
PY
}
vrf_nexthops () {
ip -4 route show vrf "vrf-${1#vp-}" "${2}" | grep -o 'via [0-9.]*' | cut -d' ' -f2 | sort -u | tr '\n' ' ' | sed 's/ $//'
}
wait_vrf_nexthops () {
local i
for i in $(seq 1 30); do
[ "$(vrf_nexthops "${1}" "${2}")" = "${3}" ] && return 0
sleep 2
done
echo "vrf-${1#vp-} ${2} : next-hops « $(vrf_nexthops "${1}" "${2}") », « ${3} » attendu" >&2
return 1
}
ping_rate () {
vm_ssh "${1}" "${2}" "ping -q -n -c ${4:-50} -i 0.2 -W 1 ${3}" 2>/dev/null | grep -o '[0-9]* received' | cut -d' ' -f1
}
vrf_route_via () {
ip -4 route show vrf "vrf-${1#vp-}" "${2}" | grep -q "via ${3} "
}
wait_vrf_route () {
local i
for i in $(seq 1 30); do
vrf_route_via "$@" && return 0
sleep 2
done
echo "vrf-${1#vp-} : pas de route ${2} via ${3}" >&2
return 1
}
vrf_members () {
ip -o link show master "vrf-${1#vp-}" | awk -F': ' '{print $2}' | cut -d@ -f1 | sort | tr '\n' ' ' | sed 's/ $//'
}
netns_ping_wait () {
local i
for i in $(seq 1 40); do
ip netns exec "${1}" ping -c 1 -W 2 "${2}" >/dev/null 2>&1 && return 0
sleep 5
done
echo "${2} injoignable depuis ${1}" >&2
return 1
}
l3vni_ready () {
local out
out=$(vtysh -c "show evpn vni ${1}") &&
grep -q 'Type: L3' <<<"${out}" &&
grep -q 'State: Up' <<<"${out}" &&
grep -qi "Router MAC: ${2}" <<<"${out}"
}
wait_l3vni () {
local i
for i in $(seq 1 15); do
l3vni_ready "$@" && return 0
sleep 2
done
echo "VNI ${1} : pas de type L3 actif avec la RMAC ${2}" >&2
return 1
}
vtep_host () {
ip -4 route get 10.255.255.1 | grep -o 'src [0-9.]*' | cut -d' ' -f2
}
bgp_paths () {
vtysh -c "show bgp vrf vrf-${1#vp-} ipv4 unicast ${2} json" 2>/dev/null | jq -r '(.paths // []) | length'
}
bgp_best () {
vtysh -c "show bgp vrf vrf-${1#vp-} ipv4 unicast ${2} json" 2>/dev/null |
jq -r '(.paths // [])[] | select(.bestpath.overall == true) | "\(.nexthops[0].ip) (\(.bestpath.selectionReason // "seul chemin"))"'
}
sources_reach () {
local vpc="${1}" bridge="${2}" base="${3}" dst="${4}" n ok=0 total=0
for n in $(seq 20 59); do
ip -n "${vpc}" addr add "${base}.${n}/32" dev "${bridge}" 2>/dev/null
ip netns exec "${vpc}" ping -n -c 2 -W 1 -I "${base}.${n}" "${dst}" >/dev/null 2>&1 && ok=$((ok + 1))
total=$((total + 1))
ip -n "${vpc}" addr del "${base}.${n}/32" dev "${bridge}"
done
echo "${ok}/${total}"
}
watchdog_reported () {
journalctl -u agent --since "-${2:-120}s" --no-pager -o cat | grep -F 'watchdog: inconsistency detected' | grep -qF -- "${1}"
}
wait_watchdog () {
local i
for i in $(seq 1 30); do
watchdog_reported "$@" && return 0
sleep 2
done
echo "watchdog : « ${1} » non signalé" >&2
return 1
}

View file

@ -133,6 +133,84 @@ test_wait_state () {
teardown
}
test_vrf_route_via_matches_the_next_hop_exactly () {
setup "vrf_route_via : next-hop exact dans la bonne VRF"
local stub='ip () { [ "$*" = "-4 route show vrf vrf-s7 10.241.1.10" ] && echo "10.241.1.10 nhid 12 via 192.168.14.11 dev brl3-s7 proto bgp metric 20 onlink"; }; '
[[ $(node "${stub}vrf_route_via vp-s7 10.241.1.10 192.168.14.11 && echo OUI") == OUI ]] || fail "route présente refusée"
[[ $(node "${stub}vrf_route_via vp-s7 10.241.1.10 192.168.14.1 || echo NON") == NON ]] || fail "192.168.14.1 pris pour 192.168.14.11"
[[ $(node "${stub}vrf_route_via vp-s7b 10.241.1.10 192.168.14.11 || echo NON") == NON ]] || fail "mauvaise VRF acceptée"
teardown
}
test_vrf_members_lists_interface_names () {
setup "vrf_members : noms triés, sans le suffixe @ du veth"
[[ $(node 'ip () { printf "%s\n" "15: l3-s7-o@if14: <UP> mtu 1500 master vrf-s7" "12: brl3-s7: <UP> mtu 1500 master vrf-s7"; }; vrf_members vp-s7') == "brl3-s7 l3-s7-o" ]] \
|| fail "lu : $(node 'ip () { printf "%s\n" "15: l3-s7-o@if14: <UP>" "12: brl3-s7: <UP>"; }; vrf_members vp-s7')"
teardown
}
test_vm_create_is_idempotent () {
setup "vm_create : VM déjà en running, rien n'est copié ni envoyé"
[[ $(node 'api_state () { echo running; }; cp () { echo COPIE; }; api_post () { echo POST; }; vm_create v sn 10.0.0.10 && echo OK') == OK ]] \
|| fail "VM existante recréée"
teardown
}
test_l3vni_ready_requires_type_state_and_rmac () {
setup "l3vni_ready : type L3, état Up et RMAC exigés"
local out='VNI: 2700\n Type: L3\n State: Up\n Router MAC: 02:00:00:00:27:02'
[[ $(node "vtysh () { printf '${out}\n'; }; l3vni_ready 2700 02:00:00:00:27:02 && echo OUI") == OUI ]] || fail "VNI prête refusée"
[[ $(node "vtysh () { printf '${out}\n'; }; l3vni_ready 2700 02:00:00:00:27:01 || echo NON") == NON ]] || fail "mauvaise RMAC acceptée"
[[ $(node "vtysh () { printf '${out/Up/Down}\n'; }; l3vni_ready 2700 02:00:00:00:27:02 || echo NON") == NON ]] || fail "état Down accepté"
[[ $(node "vtysh () { printf '${out/L3/L2}\n'; }; l3vni_ready 2700 02:00:00:00:27:02 || echo NON") == NON ]] || fail "VNI L2 acceptée"
teardown
}
test_vrf_nexthops_lists_every_ecmp_member () {
setup "vrf_nexthops : un chemin, plusieurs chemins, aucun"
[[ $(node 'ip () { echo "10.242.1.50 nhid 9 via 192.168.14.12 dev brl3-s8 proto bgp metric 20 onlink"; }; vrf_nexthops vp-s8 10.242.1.50') == 192.168.14.12 ]] || fail "un chemin"
[[ $(node 'ip () { printf "%s\n" "10.242.1.0/24 nhid 90 proto bgp metric 20" " nexthop via 192.168.14.12 dev brl3-s8 weight 1 onlink" " nexthop via 192.168.14.11 dev brl3-s8 weight 1 onlink"; }; vrf_nexthops vp-s8 10.242.1.0/24') == "192.168.14.11 192.168.14.12" ]] || fail "ECMP"
[[ -z $(node 'ip () { :; }; vrf_nexthops vp-s8 10.242.1.50') ]] || fail "aucun chemin"
teardown
}
test_bgp_best_reports_next_hop_and_reason () {
setup "bgp_paths / bgp_best : nombre de chemins, meilleur next-hop et raison"
local json='{"prefix":"10.242.1.50/32","paths":[{"nexthops":[{"ip":"192.168.14.12"}]},{"nexthops":[{"ip":"192.168.14.11"}],"bestpath":{"overall":true,"selectionReason":"Router ID"}}]}'
[[ $(node "vtysh () { echo '${json}'; }; bgp_paths vp-s8 10.242.1.50/32") == 2 ]] || fail "nombre de chemins"
[[ $(node "vtysh () { echo '${json}'; }; bgp_best vp-s8 10.242.1.50/32") == "192.168.14.11 (Router ID)" ]] || fail "meilleur : $(node "vtysh () { echo '${json}'; }; bgp_best vp-s8 10.242.1.50/32")"
[[ $(node "vtysh () { echo '{}'; }; bgp_paths vp-s8 10.242.1.50/32") == 0 ]] || fail "préfixe absent"
teardown
}
test_vpc_create_sends_the_l3vni_only_when_given () {
setup "vpc_create : l3vni transmise si donnée, absente sinon"
local stub='api_state () { echo; }; wait_state () { :; }; api_post () { echo "$1 $2"; }; '
[[ $(node "${stub}vpc_create vp-s7 10.241.0.0/16 2700") == 'vpcs {"name":"vp-s7","cidr":"10.241.0.0/16","l3vni":2700}' ]] \
|| fail "avec l3vni : $(node "${stub}vpc_create vp-s7 10.241.0.0/16 2700")"
[[ $(node "${stub}vpc_create vp-s1 10.210.0.0/16") == 'vpcs {"name":"vp-s1","cidr":"10.210.0.0/16"}' ]] \
|| fail "sans l3vni : $(node "${stub}vpc_create vp-s1 10.210.0.0/16")"
teardown
}
test_api_code_returns_the_http_status () {
setup "api_code : méthode, chemin et code HTTP"
[[ $(node 'curl () { echo "$*" >&2; echo 409; }; api_code DELETE subnets/sn-a 2>/dev/null') == 409 ]] || fail "code"
[[ $(node 'curl () { echo "$*"; }; api_code DELETE subnets/sn-a') == "-s -o /dev/null -w %{http_code} -X DELETE http://127.0.0.1:8080/subnets/sn-a" ]] \
|| fail "appel : $(node 'curl () { echo "$*"; }; api_code DELETE subnets/sn-a')"
teardown
}
test_watchdog_reported_matches_only_watchdog_alerts () {
setup "watchdog_reported : alerte du watchdog contenant le texte, rien d'autre"
local alert='{"level":"ERROR","msg":"watchdog: inconsistency detected","kind":"vpc","name":"vp-s8","problem":"route 10.242.1.99/32 exported in vrf-s8 without a running owner: its traffic is black-holed"}'
local other='{"level":"ERROR","msg":"command failed","error":"route 10.242.1.99/32 exported in vrf-s8 without a running owner"}'
[[ $(node "journalctl () { echo '${alert}'; }; watchdog_reported 'route 10.242.1.99/32 exported in vrf-s8 without a running owner' && echo OUI") == OUI ]] || fail "alerte non trouvée"
[[ $(node "journalctl () { echo '${other}'; }; watchdog_reported 'route 10.242.1.99/32 exported in vrf-s8' || echo NON") == NON ]] || fail "message hors watchdog accepté"
[[ $(node "journalctl () { echo '${alert}'; }; watchdog_reported 'route 10.242.1.98/32' || echo NON") == NON ]] || fail "autre route acceptée"
teardown
}
for T in $(declare -F | awk '{print $3}' | grep '^test_'); do
"${T}"
done

View file

@ -0,0 +1,73 @@
on hv1 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv1)"; exit 0; }
KEY=$(vm_key)
check "hv1 : base BGP posée par l'agent et enregistrée dans frr.conf" grep -qx ' neighbor 10.255.255.1 peer-group fabric' /etc/frr/frr.conf
check "hv1 : VPC vp-s7, l3vni 2700" vpc_create vp-s7 10.241.0.0/16 2700
check "hv1 : subnet sn-s7d (VNI 2711), seulement sur hv1" subnet_create sn-s7d vp-s7 2711 10.241.1.1 10.241.1.0/24
check "hv1 : VM s7-a" vm_create s7-a sn-s7d 10.241.1.10 "${KEY}"
NODE
on hv2 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv2)"; exit 0; }
check "hv2 : VPC vp-s7, l3vni 2700" vpc_create vp-s7 10.241.0.0/16 2700
check "hv2 : subnet sn-s7e (VNI 2712), seulement sur hv2" subnet_create sn-s7e vp-s7 2712 10.241.2.1 10.241.2.0/24
check "hv2 : VM s7-b" vm_create s7-b sn-s7e 10.241.2.10
check "hv2 : VPC vp-s7b, même plage, l3vni 2701" vpc_create vp-s7b 10.241.0.0/16 2701
check "hv2 : subnet sn-s7x (VNI 2713), même plage que sn-s7e" subnet_create sn-s7x vp-s7b 2713 10.241.2.1 10.241.2.0/24
check "hv2 : VM s7-x dans vp-s7b" vm_create s7-x sn-s7x 10.241.2.20
check "hv2 : l3vni 2700 déjà prise par vp-s7, refusée (409)" test "$(curl -s -o /dev/null -w '%{http_code}' -X POST -H 'Content-Type: application/json' -d '{"name":"vp-s7c","cidr":"10.249.0.0/16","l3vni":2700}' "${API}/vpcs")" = 409
NODE
on hv1 <<'NODE'
check "s7-a joignable" vm_wait vp-s7 10.241.1.10
check "s7-a : route vers la VPC 10.241.0.0/16 via interface_ip (DHCP)" route_via vp-s7 10.241.1.10 10.241.0.0/16 10.241.1.1
check "hv1 : vrf-s7 contient exactement brl3-s7 et l3-s7-o" sh -c "[ \"\$1\" = 'brl3-s7 l3-s7-o' ]" _ "$(vrf_members vp-s7)"
check "hv1 : brl3-s7 sans adresse IPv4" sh -c "! ip -4 -o addr show dev brl3-s7 | grep -q inet"
check "hv1 : RMAC de brl3-s7 dérivée du VTEP 192.168.14.11" sh -c "ip -o link show brl3-s7 | grep -q 'link/ether 02:02:c0:a8:0e:0b '"
check "hv1 : route du supernet dans vp-s7 vers le transit" sh -c "ip -n vp-s7 -4 route show 10.241.0.0/16 | grep -q 'via 169.254.0.1 dev l3-s7-i'"
check "hv1 : forwarding sur brl3-s7 et l3-s7-o" sh -c "[ \"\$(sysctl -n net.ipv4.conf.brl3-s7.forwarding net.ipv4.conf.l3-s7-o.forwarding | tr '\n' ' ')\" = '1 1 ' ]"
check "hv1 : ip_forward dans le netns vp-s7" sh -c "[ \"\$(ip netns exec vp-s7 sysctl -n net.ipv4.ip_forward)\" = 1 ]"
info "hv1 : ip_forward global de l'hôte : $(sysctl -n net.ipv4.ip_forward) (non modifié par l'agent)"
check "hv1 : vrf-s7 exporte le subnet local 10.241.1.0/24 (agent)" vrf_route_via vp-s7 10.241.1.0/24 169.254.0.2
check "hv1 : vrf-s7 exporte s7-a 10.241.1.10/32 (agent)" vrf_route_via vp-s7 10.241.1.10 169.254.0.2
check "hv1 : session vers le RR en iBGP (internal link)" sh -c "vtysh -c 'show bgp neighbors 10.255.255.1' | grep -q 'internal link'"
NODE
on hv2 <<'NODE'
check "hv2 : s7-b joignable depuis son netns" netns_ping_wait vp-s7 10.241.2.10
check "hv2 : s7-x joignable depuis son netns (témoin)" netns_ping_wait vp-s7b 10.241.2.20
check "hv2 : VNI 2700 de type L3, active, RMAC 02:02:c0:a8:0e:0c" wait_l3vni 2700 02:02:c0:a8:0e:0c
check "hv2 : VNI 2701 de type L3, active, RMAC 02:02:c0:a8:0e:0c" wait_l3vni 2701 02:02:c0:a8:0e:0c
check "hv2 : vrf-s7 apprend 10.241.1.10/32 via le VTEP de hv1" wait_vrf_route vp-s7 10.241.1.10 192.168.14.11
check "hv2 : vrf-s7 apprend 10.241.1.0/24 via le VTEP de hv1" wait_vrf_route vp-s7 10.241.1.0/24 192.168.14.11
check "hv2 : RMAC de hv1 dans la FDB de vxl3-s7" sh -c "bridge fdb show dev vxl3-s7 | grep -q '02:02:c0:a8:0e:0b dst 192.168.14.11'"
NODE
on rr1 <<'NODE'
check "rr1 : RT-5 10.241.1.10/32 de hv1 (RD 192.168.14.11:2700) reçue et réfléchie" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.11:2700 type prefix' | grep -q '\[10.241.1.10\]'"
check "rr1 : RT-5 10.241.2.20/32 de vp-s7b (RD 192.168.14.12:2701) présente (témoin du test négatif)" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.12:2701 type prefix' | grep -q '\[10.241.2.20\]'"
NODE
on hv1 <<'NODE'
check "hv1 : VNI 2700 de type L3, active, RMAC 02:02:c0:a8:0e:0b" wait_l3vni 2700 02:02:c0:a8:0e:0b
check "hv1 : vrf-s7 apprend 10.241.2.10/32 via le VTEP de hv2" wait_vrf_route vp-s7 10.241.2.10 192.168.14.12
check "hv1 : aucun VXLAN de sn-s7e (VNI 2712) sur hv1" sh -c "! ip link show vxlan-2712 >/dev/null 2>&1"
for i in $(seq 1 24); do vm_ssh vp-s7 10.241.1.10 'ping -c 1 -W 2 10.241.2.10' >/dev/null 2>&1 && break; sleep 5; done
check "s7-a (sn-s7d, hv1) joint s7-b (sn-s7e, hv2) par le L3VNI, forwarding par interface" vm_ssh vp-s7 10.241.1.10 'ping -c 3 -W 2 10.241.2.10'
check "trame pleine taille : 1472 octets en -M do" vm_ssh vp-s7 10.241.1.10 'ping -M do -s 1472 -c 2 -W 2 10.241.2.10'
check "1473 octets refusés localement (MTU 1500)" vm_grep vp-s7 10.241.1.10 'ping -M do -s 1473 -c 1 -W 2 10.241.2.10' 'message too long'
check "TTL 1 : expire à la gateway du subnet, netns de hv1 (10.241.1.1)" vm_grep vp-s7 10.241.1.10 'ping -n -c 3 -i 1.2 -W 2 -t 1 10.241.2.10' 'From 10.241.1.1 .*exceeded'
check "TTL 2 : expire dans la VRF de hv1 (169.254.0.1)" vm_grep vp-s7 10.241.1.10 'ping -n -c 3 -i 1.2 -W 2 -t 2 10.241.2.10' 'From 169.254.0.1 .*exceeded'
check "TTL 5 : atteint s7-b — quatre routeurs : gateway hv1, VRF hv1, VRF hv2, netns hv2" vm_ssh vp-s7 10.241.1.10 'ping -n -c 1 -W 2 -t 5 10.241.2.10'
check "hv1 : vrf-s7 n'importe pas 10.241.2.20/32 de vp-s7b (RT 64600:2701)" sh -c "[ -z \"\$(ip -4 route show vrf vrf-s7 10.241.2.20)\" ]"
check "s7-a ne joint pas s7-x, autre VPC, même plage" vm_fails vp-s7 10.241.1.10 'ping -c 3 -W 2 10.241.2.20'
NODE
on hv2 <<'NODE'
BGPD=$(pidof bgpd)
check "hv2 : suppression de sn-s7x refusée tant que s7-x existe (409)" test "$(api_code DELETE subnets/sn-s7x)" = 409
check "hv2 : suppression de s7-x" vm_delete s7-x
check "hv2 : vrf-s7b ne porte plus le /32 de s7-x" test -z "$(ip -4 route show vrf vrf-s7b 10.241.2.20/32)"
check "hv2 : suppression de sn-s7x" api_delete subnets/sn-s7x
check "hv2 : sn-s7x supprimé" wait_state subnets/sn-s7x deleted
check "hv2 : suppression de vp-s7b" api_delete vpcs/vp-s7b
check "hv2 : vp-s7b supprimé" wait_state vpcs/vp-s7b deleted
check "hv2 : plus aucune interface de vp-s7b" sh -c "! ip -o link show | grep -qE '(vrf|brl3|vxl3)-s7b|l3-s7b-o'"
check "hv2 : plus rien de vrf-s7b dans FRR, en mémoire ni dans frr.conf" sh -c "! vtysh -c 'show running-config' | grep -q 'vrf-s7b' && ! grep -q 'vrf-s7b' /etc/frr/frr.conf"
check "hv2 : bgpd n'a pas redémarré pendant le démontage" sh -c "[ \"\$(pidof bgpd)\" = '${BGPD}' ]"
check "hv2 : vp-s7 toujours en service" wait_l3vni 2700 02:02:c0:a8:0e:0c
NODE

View file

@ -0,0 +1,94 @@
on hv1 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv1)"; exit 0; }
check "hv1 : VPC vp-s8, l3vni 2800" vpc_create vp-s8 10.242.0.0/16 2800
check "hv1 : subnet sn-s8s (VNI 2811)" subnet_create sn-s8s vp-s8 2811 10.242.1.1 10.242.1.0/24
check "hv1 : VM s8-m1 10.242.1.50" vm_create s8-m1 sn-s8s 10.242.1.50
check "hv1 : s8-m1 répond depuis son netns" netns_ping_wait vp-s8 10.242.1.50
check "hv1 : /24 et /32 exportés par l'agent" sh -c "ip -4 route show vrf vrf-s8 | grep -q '^10.242.1.0/24 via 169.254.0.2' && ip -4 route show vrf vrf-s8 | grep -q '^10.242.1.50 via 169.254.0.2'"
NODE
on hv2 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv2)"; exit 0; }
check "hv2 : VPC vp-s8, l3vni 2800" vpc_create vp-s8 10.242.0.0/16 2800
check "hv2 : aucun subnet de vp-s8 au départ" sh -c "! ip link show vxlan-2811 >/dev/null 2>&1"
NODE
on hv3 <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (hv3)"; exit 0; }
KEY=$(vm_key)
check "hv3 : VPC vp-s8, l3vni 2800" vpc_create vp-s8 10.242.0.0/16 2800
check "hv3 : subnet sn-s8t (VNI 2812), seulement sur hv3" subnet_create sn-s8t vp-s8 2812 10.242.2.1 10.242.2.0/24
check "hv3 : VM observatrice s8-o 10.242.2.10" vm_create s8-o sn-s8t 10.242.2.10 "${KEY}"
check "s8-o joignable" vm_wait vp-s8 10.242.2.10
check "hv3 : aucun VXLAN de sn-s8s sur l'observateur" sh -c "! ip link show vxlan-2811 >/dev/null 2>&1"
check "hv3 : /32 de s8-m1 via hv1 seulement" wait_vrf_nexthops vp-s8 10.242.1.50 192.168.14.11
for i in $(seq 1 24); do vm_ssh vp-s8 10.242.2.10 'ping -c 1 -W 2 10.242.1.50' >/dev/null 2>&1 && break; sleep 5; done
check "s8-o (hv3) joint s8-m1 (hv1)" vm_ssh vp-s8 10.242.2.10 'ping -n -c 3 -W 2 10.242.1.50'
check "1472 octets en -M do" vm_ssh vp-s8 10.242.2.10 'ping -n -M do -s 1472 -c 2 -W 2 10.242.1.50'
NODE
on hv1 <<'NODE'
check "migration simple, 1 — suppression de s8-m1 sur hv1 : son /32 part en premier" vm_delete s8-m1
check "hv1 : plus de /32 pour 10.242.1.50 dans vrf-s8" test -z "$(ip -4 route show vrf vrf-s8 10.242.1.50/32 | grep 169.254.0.2)"
NODE
on hv3 <<'NODE'
check "hv3 : plus aucun /32 pour 10.242.1.50" wait_vrf_nexthops vp-s8 10.242.1.50 ""
check "hv3 : le /24 de sn-s8s reste annoncé par hv1 (filet)" wait_vrf_nexthops vp-s8 10.242.1.0/24 192.168.14.11
NODE
on hv2 <<'NODE'
check "migration simple, 2 — sn-s8s créé sur hv2 (même VNI 2811)" subnet_create sn-s8s vp-s8 2811 10.242.1.1 10.242.1.0/24
check "migration simple, 3 — VM s8-m2 10.242.1.50 sur hv2" vm_create s8-m2 sn-s8s 10.242.1.50
check "hv2 : s8-m2 répond depuis son netns" netns_ping_wait vp-s8 10.242.1.50
NODE
on hv3 <<'NODE'
start=${SECONDS}
check "hv3 : /32 de 10.242.1.50 via hv2 seulement" wait_vrf_nexthops vp-s8 10.242.1.50 192.168.14.12
info "hv3 : /32 de hv2 installé $(( SECONDS - start )) s après le passage en running de s8-m2"
check "hv3 : /24 de sn-s8s en ECMP vers hv1 et hv2" wait_vrf_nexthops vp-s8 10.242.1.0/24 "192.168.14.11 192.168.14.12"
for i in $(seq 1 24); do vm_ssh vp-s8 10.242.2.10 'ping -c 1 -W 2 10.242.1.50' >/dev/null 2>&1 && break; sleep 5; done
check "s8-o joint s8-m2 par son /32" vm_ssh vp-s8 10.242.2.10 'ping -n -c 3 -W 2 10.242.1.50'
info "après migration simple : $(ping_rate vp-s8 10.242.2.10 10.242.1.50 50)/50 réponses"
NODE
on hv1 <<'NODE'
info "orchestrée, 1 — sn-s8s présent sur hv1 (destination), /24 annoncé"
check "orchestrée, 2 — VM s8-m3 10.242.1.50 sur hv1 pendant que s8-m2 tourne sur hv2" vm_create s8-m3 sn-s8s 10.242.1.50
check "hv1 : s8-m3 répond depuis son netns" netns_ping_wait vp-s8 10.242.1.50
NODE
on rr1 <<'NODE'
check "rr1 : MAC de gateway de sn-s8s propre à chaque hôte, hv1 (02:03:c0:a8:0e:0b) et hv2 (02:03:c0:a8:0e:0c)" sh -c "r=\$(vtysh -c 'show bgp l2vpn evpn route type macip'); echo \"\$r\" | grep -qi '02:03:c0:a8:0e:0b' && echo \"\$r\" | grep -qi '02:03:c0:a8:0e:0c'"
NODE
on hv1 <<'NODE'
check "hv1 : aucune MAC en double sur la VNI 2811" sh -c "! vtysh -c 'show evpn mac vni 2811 duplicate' | grep -qiE '([0-9a-f]{2}:){5}[0-9a-f]{2}'"
NODE
on hv3 <<'NODE'
for i in $(seq 1 30); do [ "$(bgp_paths vp-s8 10.242.1.50/32)" = 2 ] && break; sleep 2; done
info "orchestrée : chemins BGP pour 10.242.1.50/32 : $(bgp_paths vp-s8 10.242.1.50/32) ; meilleur : $(bgp_best vp-s8 10.242.1.50/32) ; installés : $(vrf_nexthops vp-s8 10.242.1.50)"
check "orchestrée : deux /32 annoncés, hv1 et hv2" wait_vrf_nexthops vp-s8 10.242.1.50 "192.168.14.11 192.168.14.12"
check "deux /32, subnet présent des deux côtés : les 40 sources joignent 10.242.1.50, quel que soit le chemin ECMP" sh -c "[ \"\$1\" = 40/40 ]" _ "$(sources_reach vp-s8 br-s8t 10.242.2 10.242.1.50)"
NODE
on hv2 <<'NODE'
check "orchestrée, 3 — sn-s8s non supprimable sur hv2 tant que s8-m2 existe (409)" test "$(api_code DELETE subnets/sn-s8s)" = 409
check "orchestrée, 4 — suppression de s8-m2 sur hv2 (source) : son /32 part en premier" vm_delete s8-m2
check "orchestrée, 5 — suppression de sn-s8s sur hv2" api_delete subnets/sn-s8s
check "sn-s8s supprimé sur hv2" wait_state subnets/sn-s8s deleted
NODE
on hv3 <<'NODE'
check "hv3 : /32 de 10.242.1.50 via hv1 seulement" wait_vrf_nexthops vp-s8 10.242.1.50 192.168.14.11
check "hv3 : /24 de sn-s8s via hv1 seulement" wait_vrf_nexthops vp-s8 10.242.1.0/24 192.168.14.11
check "après la séquence orchestrée : s8-o joint s8-m3" vm_ssh vp-s8 10.242.2.10 'ping -n -c 3 -W 2 10.242.1.50'
check "après la séquence orchestrée : les 40 sources joignent s8-m3" sh -c "[ \"\$1\" = 40/40 ]" _ "$(sources_reach vp-s8 br-s8t 10.242.2 10.242.1.50)"
NODE
on hv1 <<'NODE'
check "ex-pire cas — suppression de sn-s8s sur hv1 refusée tant que s8-m3 existe (409)" test "$(api_code DELETE subnets/sn-s8s)" = 409
check "ex-pire cas — sn-s8s toujours running sur hv1" test "$(api_state subnets/sn-s8s)" = running
check "ex-pire cas — /32 et /24 toujours exportés par hv1" sh -c "ip -4 route show vrf vrf-s8 | grep -q '^10.242.1.50 via 169.254.0.2' && ip -4 route show vrf vrf-s8 | grep -q '^10.242.1.0/24 via 169.254.0.2'"
NODE
on hv1 <<'NODE'
check "watchdog : /32 orphelin posé à la main dans vrf-s8" ip route replace 10.242.1.99/32 via 169.254.0.2 dev l3-s8-o vrf vrf-s8
check "watchdog : /32 orphelin signalé comme trou noir" wait_watchdog "route 10.242.1.99/32 exported in vrf-s8 without a running owner"
check "watchdog : retrait du /32 orphelin" ip route del 10.242.1.99/32 vrf vrf-s8
check "watchdog : /32 de s8-m3 retiré à la main" ip route del 10.242.1.50/32 vrf vrf-s8
check "watchdog : /32 manquant signalé" wait_watchdog "route 10.242.1.50/32 not exported in vrf-s8"
check "watchdog : /32 de s8-m3 rétabli" ip route replace 10.242.1.50/32 via 169.254.0.2 dev l3-s8-o vrf vrf-s8
check "watchdog : aucune alerte BGP ni L3VNI sur hv1" sh -c "! journalctl -u agent --since '-60s' --no-pager -o cat | grep -F 'watchdog: inconsistency detected' | grep -qE '\"kind\":\"bgp\"|l3vni [0-9]|interface (vrf|brl3|vxl3|l3)-'"
NODE
on hv3 <<'NODE'
check "après les essais du watchdog : s8-o joint s8-m3" vm_ssh vp-s8 10.242.2.10 'ping -n -c 3 -W 2 10.242.1.50'
NODE

View file

@ -0,0 +1,45 @@
for host in hv2 hv3; do
on "${host}" "HOST=${host}" <<'NODE'
two_image || { echo "ÉCHOUÉ: image compatible two (${HOST})"; exit 0; }
KEY=$(vm_key)
case "${HOST}" in hv2) n=1 ;; hv3) n=2 ;; esac
check "${HOST} : VPC vp-s9r, l3vni 2900" vpc_create vp-s9r 10.250.0.0/16 2900
check "${HOST} : subnet sn-s9r1 (VNI 2911)" subnet_create sn-s9r1 vp-s9r 2911 10.250.1.1 10.250.1.0/24
check "${HOST} : subnet sn-s9r2 (VNI 2912)" subnet_create sn-s9r2 vp-s9r 2912 10.250.2.1 10.250.2.0/24
check "${HOST} : VM s9-r1-${n} 10.250.1.1${n}" vm_create "s9-r1-${n}" sn-s9r1 "10.250.1.1${n}" "${KEY}"
check "${HOST} : VM s9-r2-${n} 10.250.2.1${n}" vm_create "s9-r2-${n}" sn-s9r2 "10.250.2.1${n}" "${KEY}"
check "${HOST} : VPC vp-s9n, sans l3vni" vpc_create vp-s9n 10.251.0.0/16
check "${HOST} : subnet sn-s9n1 (VNI 2921)" subnet_create sn-s9n1 vp-s9n 2921 10.251.1.1 10.251.1.0/24
check "${HOST} : subnet sn-s9n2 (VNI 2922)" subnet_create sn-s9n2 vp-s9n 2922 10.251.2.1 10.251.2.0/24
check "${HOST} : VM s9-n1-${n} 10.251.1.1${n}" vm_create "s9-n1-${n}" sn-s9n1 "10.251.1.1${n}" "${KEY}"
check "${HOST} : VM s9-n2-${n} 10.251.2.1${n}" vm_create "s9-n2-${n}" sn-s9n2 "10.251.2.1${n}" "${KEY}"
NODE
done
for host in hv2 hv3; do
on "${host}" "HOST=${host}" <<'NODE'
case "${HOST}" in hv2) n=1; mac=02:03:c0:a8:0e:0c ;; hv3) n=2; mac=02:03:c0:a8:0e:0d ;; esac
for v in r n; do
vpc="vp-s9${v}"
net="10.25$([ "${v}" = r ] && echo 0 || echo 1)"
for s in 1 2; do
src="${net}.${s}.1${n}"
check "${HOST} : ${src} joignable" vm_wait "${vpc}" "${src}"
check "${HOST} : ${src} joint sa gateway ${net}.${s}.1" vm_ssh "${vpc}" "${src}" "ping -n -c 2 -W 2 ${net}.${s}.1"
check "${HOST} : ${src} voit la MAC de gateway de son hôte (${mac})" vm_grep "${vpc}" "${src}" "ip neigh show ${net}.${s}.1" "lladdr ${mac} "
for d in 1 2; do
for m in 1 2; do
dst="${net}.${d}.1${m}"
[ "${dst}" = "${src}" ] && continue
for i in $(seq 1 12); do vm_ssh "${vpc}" "${src}" "ping -n -c 1 -W 2 ${dst}" >/dev/null 2>&1 && break; sleep 5; done
check "${vpc} : ${src} (${HOST}) joint ${dst} ($([ "${d}" = "${s}" ] && echo 'même subnet' || echo 'autre subnet'), $([ "${m}" = "${n}" ] && echo 'même hôte' || echo 'autre hôte'))" \
vm_ssh "${vpc}" "${src}" "ping -n -c 3 -W 2 ${dst}"
done
done
done
done
for vni in 2911 2912 2921 2922; do
check "${HOST} : aucune MAC en double sur la VNI ${vni}" sh -c "! vtysh -c 'show evpn mac vni ${vni} duplicate' | grep -qiE '([0-9a-f]{2}:){5}[0-9a-f]{2}'"
done
NODE
done

View file

@ -0,0 +1,6 @@
bgp:
asn: 64600
route_reflectors: [10.255.255.1]
watchdog:
enabled: true
interval_seconds: 10

View file

@ -1,2 +1,8 @@
dhcp:
backend: two
bgp:
asn: 64600
route_reflectors: [10.255.255.1]
watchdog:
enabled: true
interval_seconds: 10

View file

@ -21,8 +21,9 @@ nodes:
loopback: 10.255.255.1/32, frr: frr/rr1.conf }
hv1:
{ role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.11 }, frr: frr/hv1.conf, release: 0.2.0rc003,
addresses: { underlay: 192.168.14.11 }, frr: frr/hv1.conf, release: 0.2.0rc008,
agent: agent/two.yml }
hv2:
{ role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.12 }, frr: frr/hv2.conf, release: 0.2.0rc003 }
addresses: { underlay: 192.168.14.12 }, frr: frr/hv2.conf, release: 0.2.0rc008,
agent: agent/bgp.yml }

View file

@ -0,0 +1,33 @@
name: evpn-3hv
images:
debian12:
url: https://cloud.debian.org/images/cloud/bookworm/latest/debian-12-generic-amd64.qcow2
sums: https://cloud.debian.org/images/cloud/bookworm/latest/SHA512SUMS
segments:
underlay:
switch: sw1
cidr: 192.168.14.0/24
mtu: 9000
nodes:
sw1:
{ role: switch, image: debian12, cpus: 2, memory: 1024,
secondary: { underlay: [169.254.0.1/28] }, frr: frr/sw1.conf }
rr1:
{ role: rr, image: debian12, cpus: 1, memory: 1024, segments: [underlay],
addresses: { underlay: 192.168.14.2 }, secondary: { underlay: [169.254.0.3/28] },
loopback: 10.255.255.1/32, frr: frr/rr1.conf }
hv1:
{ role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.11 }, frr: frr/hv1.conf, release: 0.2.0rc008,
agent: agent/two.yml }
hv2:
{ role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.12 }, frr: frr/hv2.conf, release: 0.2.0rc008,
agent: agent/bgp.yml }
hv3:
{ role: hypervisor, image: debian12, cpus: 4, memory: 16384, segments: [underlay],
addresses: { underlay: 192.168.14.13 }, frr: frr/hv3.conf, release: 0.2.0rc008,
agent: agent/bgp.yml }

View file

@ -2,18 +2,3 @@ frr defaults traditional
hostname hv1
log syslog informational
!
router bgp 64600
bgp router-id 192.168.14.11
no bgp default ipv4-unicast
neighbor fabric peer-group
neighbor fabric remote-as 64600
neighbor fabric capability extended-nexthop
neighbor 10.255.255.1 peer-group fabric
!
address-family l2vpn evpn
neighbor fabric activate
advertise-all-vni
exit-address-family
!
exit
!

View file

@ -2,18 +2,3 @@ frr defaults traditional
hostname hv2
log syslog informational
!
router bgp 64600
bgp router-id 192.168.14.12
no bgp default ipv4-unicast
neighbor fabric peer-group
neighbor fabric remote-as 64600
neighbor fabric capability extended-nexthop
neighbor 10.255.255.1 peer-group fabric
!
address-family l2vpn evpn
neighbor fabric activate
advertise-all-vni
exit-address-family
!
exit
!

View file

@ -0,0 +1,4 @@
frr defaults traditional
hostname hv3
log syslog informational
!