Merge branch 'feature-41'
All checks were successful
Documentation / publish (push) Successful in 1m23s
All checks were successful
Documentation / publish (push) Successful in 1m23s
This commit is contained in:
commit
4438bb3916
82 changed files with 4267 additions and 142 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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``
|
||||
|
|
|
|||
|
|
@ -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
|
||||
------
|
||||
|
||||
|
|
|
|||
|
|
@ -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`.
|
||||
|
|
|
|||
|
|
@ -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 :
|
||||
|
||||
|
|
|
|||
|
|
@ -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 :
|
||||
|
||||
|
|
|
|||
|
|
@ -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``
|
||||
|
|
|
|||
|
|
@ -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
|
||||
----------------
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
38
internal/config/agent/bgp.go
Normal file
38
internal/config/agent/bgp.go
Normal 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
|
||||
}
|
||||
54
internal/config/agent/bgp_test.go
Normal file
54
internal/config/agent/bgp_test.go
Normal 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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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"`
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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
146
internal/frr/client.go
Normal 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
321
internal/frr/client_test.go
Normal 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
155
internal/frr/config.go
Normal 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
143
internal/frr/config_test.go
Normal 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
49
internal/frr/status.go
Normal 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
|
||||
}
|
||||
50
internal/frr/status_test.go
Normal file
50
internal/frr/status_test.go
Normal 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
99
internal/frr/teardown.go
Normal 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, "; "))
|
||||
}
|
||||
159
internal/frr/teardown_test.go
Normal file
159
internal/frr/teardown_test.go
Normal 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
94
internal/l3vni/host.go
Normal 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
177
internal/l3vni/l3.go
Normal 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
260
internal/l3vni/l3_test.go
Normal 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
17
internal/l3vni/l3vni.go
Normal 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
|
||||
}
|
||||
30
internal/l3vni/l3vni_test.go
Normal file
30
internal/l3vni/l3vni_test.go
Normal 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
50
internal/l3vni/route.go
Normal 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
|
||||
}
|
||||
89
internal/l3vni/route_test.go
Normal file
89
internal/l3vni/route_test.go
Normal 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é")
|
||||
}
|
||||
}
|
||||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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, ¬Found) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
return netlink.LinkDel(link)
|
||||
}
|
||||
|
|
|
|||
21
internal/netif/mac.go
Normal file
21
internal/netif/mac.go
Normal 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
|
||||
}
|
||||
60
internal/netif/mac_test.go
Normal file
60
internal/netif/mac_test.go
Normal 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
36
internal/netif/route.go
Normal 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
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
16
internal/netif/vrf.go
Normal 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)
|
||||
}
|
||||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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
23
internal/sysctl/sysctl.go
Normal 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()
|
||||
}
|
||||
48
internal/sysctl/sysctl_test.go
Normal file
48
internal/sysctl/sysctl_test.go
Normal 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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
43
internal/vm/routes.go
Normal 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
|
||||
}
|
||||
66
internal/vm/routes_test.go
Normal file
66
internal/vm/routes_test.go
Normal 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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
232
internal/watchdog/check_l3.go
Normal file
232
internal/watchdog/check_l3.go
Normal 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
|
||||
}
|
||||
242
internal/watchdog/check_l3_test.go
Normal file
242
internal/watchdog/check_l3_test.go
Normal 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))
|
||||
}
|
||||
}
|
||||
|
|
@ -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()) {
|
||||
|
|
|
|||
|
|
@ -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é.
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -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; }
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
73
test/e2e/scenarios/s7-l3vni.sh
Normal file
73
test/e2e/scenarios/s7-l3vni.sh
Normal 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
|
||||
94
test/e2e/scenarios/s8-l3vni-migration.sh
Normal file
94
test/e2e/scenarios/s8-l3vni-migration.sh
Normal 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
|
||||
45
test/e2e/scenarios/s9-subnets-partages.sh
Normal file
45
test/e2e/scenarios/s9-subnets-partages.sh
Normal 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
|
||||
6
test/e2e/topologies/agent/bgp.yml
Normal file
6
test/e2e/topologies/agent/bgp.yml
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
bgp:
|
||||
asn: 64600
|
||||
route_reflectors: [10.255.255.1]
|
||||
watchdog:
|
||||
enabled: true
|
||||
interval_seconds: 10
|
||||
|
|
@ -1,2 +1,8 @@
|
|||
dhcp:
|
||||
backend: two
|
||||
bgp:
|
||||
asn: 64600
|
||||
route_reflectors: [10.255.255.1]
|
||||
watchdog:
|
||||
enabled: true
|
||||
interval_seconds: 10
|
||||
|
|
|
|||
|
|
@ -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 }
|
||||
|
|
|
|||
33
test/e2e/topologies/evpn-3hv.yml
Normal file
33
test/e2e/topologies/evpn-3hv.yml
Normal 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 }
|
||||
|
|
@ -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
|
||||
!
|
||||
|
|
|
|||
|
|
@ -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
|
||||
!
|
||||
|
|
|
|||
4
test/e2e/topologies/frr/hv3.conf
Normal file
4
test/e2e/topologies/frr/hv3.conf
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
frr defaults traditional
|
||||
hostname hv3
|
||||
log syslog informational
|
||||
!
|
||||
Loading…
Add table
Add a link
Reference in a new issue