From dd9844284d5837ac369d97ff3859bfc4576f63e0 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 11:53:33 +0100 Subject: [PATCH 01/17] =?UTF-8?q?f-81:=20api:=20default=5Froute=20sans=20g?= =?UTF-8?q?ateway=20r=C3=A9serv=C3=A9=20au=20mode=20bridge=20#81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GnomeZworc --- api/agent.yaml | 8 ++++--- internal/api/agent/subnet_test.go | 39 +++++++++++++++++++++++++++++++ internal/api/agent/subnets.go | 5 ++++ 3 files changed, 49 insertions(+), 3 deletions(-) diff --git a/api/agent.yaml b/api/agent.yaml index 65c2603..1f0b7bb 100644 --- a/api/agent.yaml +++ b/api/agent.yaml @@ -234,7 +234,8 @@ paths: "400": description: > Missing required field; interface_ip missing on a bridge or public_ip subnet, or - supplied on a vxlan subnet (it is computed) + supplied on a vxlan subnet (it is computed); default_route true without gateway on a + vxlan or public_ip subnet content: application/json: schema: @@ -408,8 +409,9 @@ components: description: > A default route is always advertised via DHCP; this flag only chooses its next-hop. When false, the next-hop is the subnet interface_ip. When true, it is the `gateway` - field if supplied, otherwise the gateway read from the host routing table. - The route to the VPC CIDR always keeps interface_ip as its next-hop (except in bridge + field if supplied, otherwise the gateway read from the host routing table — this last + case is bridge mode only (400 in vxlan and public_ip modes, whose guests do not share + the L2 segment of the host gateway). The route to the VPC CIDR always keeps interface_ip as its next-hop (except in bridge mode, which has no VPC route), so VPC traffic never leaves through a public gateway. default: false gateway: diff --git a/internal/api/agent/subnet_test.go b/internal/api/agent/subnet_test.go index 705a293..b6b84a9 100644 --- a/internal/api/agent/subnet_test.go +++ b/internal/api/agent/subnet_test.go @@ -499,3 +499,42 @@ func TestGetSubnet_RelayIPOnlyForVxlan(t *testing.T) { t.Errorf("relay_ip inattendus dans la liste : %v", relays) } } + +func TestPostSubnet_DefaultRouteWithoutGatewayOnlyForBridge(t *testing.T) { + for _, req := range []SubnetCreateRequest{ + {Mode: "", CIDR: "10.0.0.0/24"}, + {Mode: "vxlan", VxlanID: 1101, CIDR: "10.0.0.0/24"}, + {Mode: "public_ip", InterfaceIP: "203.0.113.254", CIDR: "203.0.113.0/24"}, + } { + s, db := newTestServer(t) + kv.AddInDB(db, "vpc/vpc-1/state", "running") + req.Name, req.VPC, req.DefaultRoute = "sn-1", "vpc-1", true + w := postSubnetRequest(t, s, req) + if w.Code != http.StatusBadRequest { + t.Errorf("mode %q : attendu 400, obtenu %d : %s", req.Mode, w.Code, w.Body.String()) + } + if !strings.Contains(w.Body.String(), "default_route without gateway is only allowed for bridge subnets") { + t.Errorf("mode %q : message %s", req.Mode, w.Body.String()) + } + if _, err := kv.GetFromDB(db, "subnet/sn-1/state"); err == nil { + t.Errorf("mode %q : aucun subnet ne doit être créé", req.Mode) + } + } +} + +func TestPostSubnet_DefaultRouteAccepted(t *testing.T) { + for _, req := range []SubnetCreateRequest{ + {Mode: "bridge", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24"}, + {Mode: "bridge", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24", Gateway: "10.0.0.254"}, + {Mode: "", CIDR: "10.0.0.0/24", Gateway: "10.0.0.1"}, + {Mode: "vxlan", VxlanID: 1101, CIDR: "10.0.0.0/24", Gateway: "10.0.0.1"}, + {Mode: "public_ip", InterfaceIP: "203.0.113.254", CIDR: "203.0.113.0/24", Gateway: "203.0.113.1"}, + } { + s, db := newTestServer(t) + kv.AddInDB(db, "vpc/vpc-1/state", "running") + req.Name, req.VPC, req.DefaultRoute = "sn-1", "vpc-1", true + if w := postSubnetRequest(t, s, req); w.Code != http.StatusAccepted { + t.Errorf("mode %q gateway %q : attendu 202, obtenu %d : %s", req.Mode, req.Gateway, w.Code, w.Body.String()) + } + } +} diff --git a/internal/api/agent/subnets.go b/internal/api/agent/subnets.go index 5390d57..64f3ac7 100644 --- a/internal/api/agent/subnets.go +++ b/internal/api/agent/subnets.go @@ -78,6 +78,11 @@ func (s *Server) postSubnet(w http.ResponseWriter, r *http.Request) { json.NewEncoder(w).Encode(ErrorResponse{Error: "interface_ip is computed for vxlan subnets, do not set it"}) return } + if req.DefaultRoute && req.Gateway == "" && req.Mode != subnet.ModeBridge { + w.WriteHeader(http.StatusBadRequest) + json.NewEncoder(w).Encode(ErrorResponse{Error: "default_route without gateway is only allowed for bridge subnets: the host gateway is not on the subnet"}) + return + } cmd := dispatcher.CreateSubnetCommand{ Name: req.Name, VPC: req.VPC, From cc8ddfe8824d2f2059929c52007abeb4292c37bb Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 11:53:39 +0100 Subject: [PATCH 02/17] f-81: l3vni: route unreachable default dans chaque VRF de VPC #81 Signed-off-by: GnomeZworc --- internal/l3vni/host.go | 10 ++++++++ internal/l3vni/l3.go | 6 +++++ internal/l3vni/l3_test.go | 42 +++++++++++++++++++++++++++++++- internal/netif/route_linux.go | 46 +++++++++++++++++++++++++++++++++++ internal/netif/route_other.go | 12 +++++++++ 5 files changed, 115 insertions(+), 1 deletion(-) diff --git a/internal/l3vni/host.go b/internal/l3vni/host.go index 4899d3e..24a6c98 100644 --- a/internal/l3vni/host.go +++ b/internal/l3vni/host.go @@ -23,6 +23,8 @@ type host interface { DeleteLink(name string) error TableRouteVia(table uint32, dst *net.IPNet, gw net.IP, iface string) error TableRouteDel(table uint32, dst *net.IPNet) error + TableUnreachableDefault(table uint32) error + TableUnreachableDefaultDel(table uint32) error ApplyVRF(v frr.VRF) error WithdrawVRF(v frr.VRF) error RemoveVRF(v frr.VRF) error @@ -87,6 +89,14 @@ func (system) TableRouteDel(table uint32, dst *net.IPNet) error { return netif.RouteDelIfExists(int(table), dst) } +func (system) TableUnreachableDefault(table uint32) error { + return netif.RouteReplaceUnreachableDefault(int(table), UnreachableMetric) +} + +func (system) TableUnreachableDefaultDel(table uint32) error { + return netif.RouteDelUnreachableDefaultIfExists(int(table), UnreachableMetric) +} + func (s system) ApplyVRF(v frr.VRF) error { return s.frr.ApplyVRF(v) } func (s system) WithdrawVRF(v frr.VRF) error { return s.frr.WithdrawVRF(v) } diff --git a/internal/l3vni/l3.go b/internal/l3vni/l3.go index 65bd453..ad22ac2 100644 --- a/internal/l3vni/l3.go +++ b/internal/l3vni/l3.go @@ -14,6 +14,8 @@ import ( "github.com/dgraph-io/badger/v4" ) +const UnreachableMetric = 4278198272 + var ( transitHost = &net.IPNet{IP: net.IPv4(169, 254, 0, 1).To4(), Mask: net.CIDRMask(30, 32)} transitNetns = &net.IPNet{IP: net.IPv4(169, 254, 0, 2).To4(), Mask: net.CIDRMask(30, 32)} @@ -84,6 +86,7 @@ func createL3(h host, cfg *configuration.Config, v l3VPC) error { run func() error }{ {"create " + v.vrf(), func() error { return h.CreateVRF(v.vrf(), v.vni) }}, + {"unreachable default in " + v.vrf(), func() error { return h.TableUnreachableDefault(v.vni) }}, {"create " + v.bridge(), func() error { return h.CreateBridge(v.bridge(), mtu, rmac) }}, {"attach " + v.bridge(), func() error { return h.SetMaster(v.bridge(), v.vrf()) }}, {"create " + v.vxlan(), func() error { return h.CreateVxlan(v.vxlan(), int(v.vni), cfg.DefaultInterface, mtu) }}, @@ -123,6 +126,9 @@ func deleteL3(h host, v l3VPC) error { return fmt.Errorf("l3vni %d: delete %s: %w", v.vni, link, err) } } + if err := h.TableUnreachableDefaultDel(v.vni); err != nil { + return fmt.Errorf("l3vni %d: delete unreachable default from table %d: %w", v.vni, v.vni, err) + } if err := h.RemoveVRF(frrVRF); err != nil { return fmt.Errorf("l3vni %d: remove frr vrf: %w", v.vni, err) } diff --git a/internal/l3vni/l3_test.go b/internal/l3vni/l3_test.go index 17e0c8c..7855f27 100644 --- a/internal/l3vni/l3_test.go +++ b/internal/l3vni/l3_test.go @@ -83,6 +83,14 @@ func (f *fakeHost) TableRouteDel(table uint32, dst *net.IPNet) error { return f.record(fmt.Sprintf("table %d del %s", table, dst)) } +func (f *fakeHost) TableUnreachableDefault(table uint32) error { + return f.record(fmt.Sprintf("table %d unreachable default", table)) +} + +func (f *fakeHost) TableUnreachableDefaultDel(table uint32) error { + return f.record(fmt.Sprintf("table %d del unreachable default", table)) +} + func (f *fakeHost) ApplyVRF(v frr.VRF) error { return f.record(fmt.Sprintf("frr apply asn=%d id=%s vni=%d vtep=%s supernet=%s", v.ASN, v.ID, v.L3VNI, v.VTEP, v.Supernet)) } @@ -121,6 +129,7 @@ func TestCreateL3FollowsTheLabRecipe(t *testing.T) { want := []string{ "vtep br-000000", "vrf vrf-s7 table 2700", + "table 2700 unreachable default", "bridge brl3-s7 mtu 1450 mac 02:02:c0:a8:0e:0b", "master brl3-s7 vrf-s7", "vxlan vxl3-s7 id 2700 dev br-000000 mtu 1450", @@ -179,6 +188,7 @@ func TestDeleteL3WithdrawsFRRThenTheKernelThenTheVRF(t *testing.T) { "del vxl3-s7", "del brl3-s7", "del vrf-s7", + "table 2700 del unreachable default", "frr remove asn=0 id=s7 vni=0", } if !reflect.DeepEqual(f.calls, want) { @@ -209,9 +219,39 @@ func TestDeleteL3KeepsTheFRRVRFWhenAKernelLinkCannotBeDeleted(t *testing.T) { } } +func TestCreateL3LeavesNoVRFWithoutItsUnreachableDefault(t *testing.T) { + f := &fakeHost{fail: map[string]error{"table 2700 unreachable default": errors.New("operation not permitted")}} + err := createL3(f, bgpConfig(), labL3(t)) + if err == nil || !strings.Contains(err.Error(), "l3vni 2700: unreachable default in vrf-s7: operation not permitted") { + t.Errorf("erreur %v", err) + } + if last := f.calls[len(f.calls)-1]; last != "table 2700 unreachable default" { + t.Errorf("appels après l'échec : %q", f.calls) + } +} + +func TestDeleteL3KeepsTheFRRVRFWhenTheUnreachableDefaultCannotBeDeleted(t *testing.T) { + f := &fakeHost{fail: map[string]error{"table 2700 del unreachable default": errors.New("operation not permitted")}} + err := deleteL3(f, labL3(t)) + if err == nil || !strings.Contains(err.Error(), "delete unreachable default from table 2700") { + t.Errorf("erreur %v", err) + } + for _, c := range f.calls { + if strings.HasPrefix(c, "frr remove") { + t.Errorf("étape exécutée après l'échec : %q", f.calls) + } + } +} + +func TestUnreachableMetricIsTheHighestRecommendedByTheKernel(t *testing.T) { + if UnreachableMetric != 4278198272 { + t.Errorf("UnreachableMetric = %d", UnreachableMetric) + } +} + func TestDeleteL3DoesNotDependOnTheAgentBGPSection(t *testing.T) { f := &fakeHost{} - if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 6 { + if err := deleteL3(f, labL3(t)); err != nil || len(f.calls) != 7 { t.Errorf("erreur %v, appels %q", err, f.calls) } } diff --git a/internal/netif/route_linux.go b/internal/netif/route_linux.go index a7be050..1001a53 100644 --- a/internal/netif/route_linux.go +++ b/internal/netif/route_linux.go @@ -3,11 +3,16 @@ package netif import ( + "errors" "net" + "syscall" "github.com/vishvananda/netlink" + "golang.org/x/sys/unix" ) +var defaultIPv4 = &net.IPNet{IP: net.IPv4zero.To4(), Mask: net.CIDRMask(0, 32)} + func RouteAdd(iface string, subnet *net.IPNet) error { return RouteAddFrom(iface, subnet, nil) } @@ -45,3 +50,44 @@ func TableRoutesVia(table int, iface string) ([]*net.IPNet, error) { } return dsts, nil } + +func unreachableDefault(table, metric int) *netlink.Route { + return &netlink.Route{ + Dst: defaultIPv4, + Table: table, + Type: unix.RTN_UNREACHABLE, + Priority: metric, + } +} + +func RouteReplaceUnreachableDefault(table, metric int) error { + return netlink.RouteReplace(unreachableDefault(table, metric)) +} + +func RouteDelUnreachableDefaultIfExists(table, metric int) error { + if err := netlink.RouteDel(unreachableDefault(table, metric)); err != nil && !errors.Is(err, syscall.ESRCH) { + return err + } + return nil +} + +func HasUnreachableDefault(table, metric int) (bool, error) { + routes, err := netlink.RouteListFiltered(netlink.FAMILY_V4, &netlink.Route{ + Table: table, + Type: unix.RTN_UNREACHABLE, + }, netlink.RT_FILTER_TABLE|netlink.RT_FILTER_TYPE) + if err != nil { + return false, err + } + for _, r := range routes { + if r.Priority == metric && (r.Dst == nil || isDefault(r.Dst)) { + return true, nil + } + } + return false, nil +} + +func isDefault(dst *net.IPNet) bool { + ones, _ := dst.Mask.Size() + return ones == 0 +} diff --git a/internal/netif/route_other.go b/internal/netif/route_other.go index d87bf82..9b7a12b 100644 --- a/internal/netif/route_other.go +++ b/internal/netif/route_other.go @@ -18,3 +18,15 @@ func RouteAddFrom(_ string, _ *net.IPNet, _ net.IP) error { func TableRoutesVia(_ int, _ string) ([]*net.IPNet, error) { return nil, errors.New("route listing is only implemented on linux") } + +func RouteReplaceUnreachableDefault(_, _ int) error { + return errors.New("not supported on this platform") +} + +func RouteDelUnreachableDefaultIfExists(_, _ int) error { + return errors.New("not supported on this platform") +} + +func HasUnreachableDefault(_, _ int) (bool, error) { + return false, errors.New("route listing is only implemented on linux") +} From 45b226f0bccb2f9f4080fd01f8bb54728e7b2fc3 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 11:53:45 +0100 Subject: [PATCH 03/17] =?UTF-8?q?f-81:=20watchdog:=20VRF=20sans=20route=20?= =?UTF-8?q?unreachable=20default=20signal=C3=A9e=20#81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GnomeZworc --- internal/watchdog/check_l3.go | 13 ++++++++++ internal/watchdog/check_l3_test.go | 38 ++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+) diff --git a/internal/watchdog/check_l3.go b/internal/watchdog/check_l3.go index 0fee453..fae7759 100644 --- a/internal/watchdog/check_l3.go +++ b/internal/watchdog/check_l3.go @@ -25,6 +25,7 @@ type l3Probe interface { NeighborEstablished(peer net.IP) (bool, error) VNI(vni uint32) (frr.VNIState, error) ExportedRoutes(table uint32, iface string) ([]*net.IPNet, error) + UnreachableDefault(table uint32) (bool, error) LinkProblem(ns, iface string) string } @@ -44,6 +45,10 @@ func (systemProbe) ExportedRoutes(table uint32, iface string) ([]*net.IPNet, err return netif.TableRoutesVia(int(table), iface) } +func (systemProbe) UnreachableDefault(table uint32) (bool, error) { + return netif.HasUnreachableDefault(int(table), l3vni.UnreachableMetric) +} + func (systemProbe) LinkProblem(ns, iface string) string { if ns == "" { return linkProblem(iface) @@ -145,6 +150,14 @@ func checkL3VPC(db *badger.DB, name string, r l3vni.Routing, rmac string, p l3Pr n.Notify(kindVPC, name, fmt.Sprintf("l3vni %d has router mac %q in frr, expected %s", r.VNI, s.RouterMAC, rmac)) } + present, err := p.UnreachableDefault(r.VNI) + switch { + case err != nil: + n.Notify(kindVPC, name, fmt.Sprintf("unreachable default of %s unreadable: %v", r.VRF, err)) + case !present: + n.Notify(kindVPC, name, fmt.Sprintf("no unreachable default in %s: traffic to an unknown destination leaves through the host routing table", r.VRF)) + } + actual, err := p.ExportedRoutes(r.VNI, r.VethHost) if err != nil { n.Notify(kindVPC, name, fmt.Sprintf("routes of %s unreadable: %v", r.VRF, err)) diff --git a/internal/watchdog/check_l3_test.go b/internal/watchdog/check_l3_test.go index c307b30..f84a6a3 100644 --- a/internal/watchdog/check_l3_test.go +++ b/internal/watchdog/check_l3_test.go @@ -19,6 +19,8 @@ type fakeProbe struct { routesErr error links map[string]string vtepErr error + unreachable map[uint32]bool + unreachErr error } func (f *fakeProbe) VTEPAddress(string) (net.IP, error) { @@ -49,6 +51,13 @@ func (f *fakeProbe) ExportedRoutes(table uint32, _ string) ([]*net.IPNet, error) return out, f.routesErr } +func (f *fakeProbe) UnreachableDefault(table uint32) (bool, error) { + if f.unreachable == nil { + return true, f.unreachErr + } + return f.unreachable[table], f.unreachErr +} + func (f *fakeProbe) LinkProblem(ns, iface string) string { return f.links[ns+"/"+iface] } @@ -240,3 +249,32 @@ func TestCheckL3VPCsReportsUnreadableRoutesAndVTEP(t *testing.T) { t.Errorf("RMAC comparée sans VTEP : %q", notified(r)) } } + +func TestCheckL3VPCsReportsAVRFWithoutUnreachableDefault(t *testing.T) { + db := newTestDB(t) + seedResource(t, db, prefixVPC, "vp-s7", state.Running) + seedKV(t, db, "vpc/vp-s7/cidr", "10.241.0.0/16") + seedKV(t, db, "vpc/vp-s7/l3vni", "2700") + seedResource(t, db, prefixVPC, "vp-s8", state.Running) + seedKV(t, db, "vpc/vp-s8/cidr", "10.242.0.0/16") + seedKV(t, db, "vpc/vp-s8/l3vni", "2800") + p := seedRoutedVPC(t) + p.vni[2800] = frr.VNIState{Type: "L3", State: "Up", RouterMAC: "02:02:c0:a8:0e:0b"} + p.unreachable = map[uint32]bool{2700: true} + r := &recorder{} + if err := CheckL3VPCs(db, bgpCfg(), p, r); err != nil { + t.Fatal(err) + } + want := []string{"vpc vp-s8: no unreachable default in vrf-s8: traffic to an unknown destination leaves through the host routing table"} + if got := notified(r); !reflect.DeepEqual(got, want) { + t.Errorf("notifications :\n%q\nattendu :\n%q", got, want) + } + + p.unreachable = map[uint32]bool{2700: true, 2800: true} + p.unreachErr = errors.New("netlink refused") + r = &recorder{} + CheckL3VPCs(db, bgpCfg(), p, r) + if !r.hasProblemContaining("unreachable default of vrf-s7 unreadable: netlink refused") || r.hasProblemContaining("no unreachable default") { + t.Errorf("notifications %q", notified(r)) + } +} From 811e69dac2cf01216f16ab11bd027185a43a5e65 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 13:18:24 +0100 Subject: [PATCH 04/17] f-87: e2e: bordures bd1 et bd2 dans evpn-3hv, VNI 66001, gateway anycast #87 Signed-off-by: GnomeZworc --- docs/developpement/lab.rst | 12 ++++++++++++ test/e2e/topologies/evpn-3hv.yml | 6 ++++++ test/e2e/topologies/frr/bd1.conf | 19 +++++++++++++++++++ test/e2e/topologies/frr/bd2.conf | 19 +++++++++++++++++++ test/e2e/topologies/provision/border.sh | 18 ++++++++++++++++++ 5 files changed, 74 insertions(+) create mode 100644 test/e2e/topologies/frr/bd1.conf create mode 100644 test/e2e/topologies/frr/bd2.conf create mode 100755 test/e2e/topologies/provision/border.sh diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index 632e03a..c292ed3 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -127,6 +127,18 @@ un subnet créé avec ``mode: bridge`` et ``iface_type: lan`` rattache son veth subnets ``vxlan`` (``iface_type: vms``, clé absente) restent sur ``default_interface`` : le VTEP ne change pas. Le bridge n'est créé qu'au premier démarrage, comme le reste du provisionnement. +**Bordures (``evpn-3hv``, #87).** ``bd1`` et ``bd2`` (``192.168.14.21`` et ``.22``) jouent les +routeurs de bordure du segment public. Ce sont des nœuds ``host`` sans agent : leur provision +(``test/e2e/topologies/provision/border.sh``) crée ``br-public``, y accroche ``vxlan-66001`` +(VNI 66001, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway +anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:01:01:d1`` (la MAC anycast +de two pour le VNI 66001), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface +``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur : iBGP AS 64600 vers les +deux route reflectors, ``advertise-all-vni``. Les adresses publiques du lab sont prises dans +``240.0.0.0/4``, réservée (RFC 1112, registre RFC 6890) et jamais routée sur Internet. Les bordures +sont déclarées après les hyperviseurs : les adresses et les taps de l'underlay ne changent pas, +ceux du segment ``lan`` sont renumérotés. + **Tester l'arbre courant plutôt que la release.** ``test/e2e/build.sh`` compile ``agent``, ``dhcp`` et ``metadata`` pour linux/amd64 dans ``test/e2e/topologies/bin/`` (ignoré par git), que les hyperviseurs reçoivent par ``files: {bin: bin}``. Après ``deploy.sh``, diff --git a/test/e2e/topologies/evpn-3hv.yml b/test/e2e/topologies/evpn-3hv.yml index 58c38d5..a32ac1c 100644 --- a/test/e2e/topologies/evpn-3hv.yml +++ b/test/e2e/topologies/evpn-3hv.yml @@ -48,3 +48,9 @@ nodes: addresses: { underlay: 192.168.14.13 }, frr: frr/hv3.conf, provision: provision/hypervisor.sh, post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin }, services: [agent.service] } + bd1: + { role: host, image: debian12, cpus: 1, memory: 1024, segments: [underlay], + addresses: { underlay: 192.168.14.21 }, frr: frr/bd1.conf, provision: provision/border.sh } + bd2: + { role: host, image: debian12, cpus: 1, memory: 1024, segments: [underlay], + addresses: { underlay: 192.168.14.22 }, frr: frr/bd2.conf, provision: provision/border.sh } diff --git a/test/e2e/topologies/frr/bd1.conf b/test/e2e/topologies/frr/bd1.conf new file mode 100644 index 0000000..0a3d79c --- /dev/null +++ b/test/e2e/topologies/frr/bd1.conf @@ -0,0 +1,19 @@ +frr defaults traditional +hostname bd1 +log syslog informational +! +router bgp 64600 + bgp router-id 192.168.14.21 + 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 +! diff --git a/test/e2e/topologies/frr/bd2.conf b/test/e2e/topologies/frr/bd2.conf new file mode 100644 index 0000000..e1ce95a --- /dev/null +++ b/test/e2e/topologies/frr/bd2.conf @@ -0,0 +1,19 @@ +frr defaults traditional +hostname bd2 +log syslog informational +! +router bgp 64600 + bgp router-id 192.168.14.22 + 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 +! diff --git a/test/e2e/topologies/provision/border.sh b/test/e2e/topologies/provision/border.sh new file mode 100755 index 0000000..524bca2 --- /dev/null +++ b/test/e2e/topologies/provision/border.sh @@ -0,0 +1,18 @@ +#!/bin/sh +set -eu +VNI=66001 +GATEWAY=240.0.0.1/24 +GATEWAY_MAC=02:01:00:01:01:d1 +DESTINATION=240.255.0.1/32 +VTEP=$(ip -4 -o addr show dev "${LAB_UPLINK}" scope global | awk 'NR == 1 {sub("/.*", "", $4); print $4}') +[ -n "${VTEP}" ] || { echo "border: no IPv4 on ${LAB_UPLINK}" >&2; exit 1; } +ip link add br-public type bridge +ip link set br-public address "${GATEWAY_MAC}" +ip link add "vxlan-${VNI}" type vxlan id "${VNI}" local "${VTEP}" dstport 4789 nolearning +ip link set "vxlan-${VNI}" mtu 1500 master br-public +ip link set "vxlan-${VNI}" up +ip link set br-public up +ip addr add "${GATEWAY}" dev br-public +ip link add internet type dummy +ip addr add "${DESTINATION}" dev internet +ip link set internet up From 583fd89adb89d5656a2fac366b359a8598f21447 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 11:53:52 +0100 Subject: [PATCH 05/17] f-81: e2e: refus du cas 2, unreachable default dans la VRF #81 Signed-off-by: GnomeZworc --- test/e2e/suite/11-validation.sh | 4 +++- test/e2e/suite/51-l3vni.sh | 11 +++++++++-- test/e2e/suite/53-watchdog-l3.sh | 8 ++++++-- 3 files changed, 18 insertions(+), 5 deletions(-) diff --git a/test/e2e/suite/11-validation.sh b/test/e2e/suite/11-validation.sh index c9684a2..04df20d 100644 --- a/test/e2e/suite/11-validation.sh +++ b/test/e2e/suite/11-validation.sh @@ -1,6 +1,6 @@ # fonctionnalité: validation de l'API — refus synchrones (400, 409, 422) des VPC, subnets et VM, sans trace en base # hôtes: hv1 -# tickets: #41, #57, #33, #62, #74 +# tickets: #41, #57, #33, #62, #74, #81 on hv1 <<'NODE' check "VPC vp-t11a, l3vni 1100 (témoin)" vpc_create vp-t11a 10.11.0.0/16 1100 @@ -19,6 +19,8 @@ check "sn-t11a : adresse d'émission calculée .253" test "$(api_field subnets/s check "subnet : nom déjà pris, 409" expect_code 409 api_post_code subnets '{"name":"sn-t11a","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1101,"cidr":"10.11.1.0/24"}' check "subnet : mode inconnu, 422" expect_code 422 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vlan","vxlan_id":1109,"cidr":"10.11.9.0/24"}' check "subnet : interface_ip fournie en vxlan, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/24","interface_ip":"10.11.9.1"}' +check "subnet : default_route sans gateway en vxlan, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/24","default_route":true}' +check "subnet : default_route sans gateway, mode omis, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","vxlan_id":1109,"cidr":"10.11.9.0/24","default_route":true}' check "subnet : interface_ip absente en bridge, 400" expect_code 400 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"bridge","cidr":"10.11.9.0/24"}' check "subnet : préfixe /30 en vxlan, 422" expect_code 422 api_post_code subnets '{"name":"sn-t11x","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1109,"cidr":"10.11.9.0/30"}' check "subnet : préfixe /29 en vxlan accepté (témoin)" expect_code 202 api_post_code subnets '{"name":"sn-t11p","vpc":"vp-t11a","mode":"vxlan","vxlan_id":1103,"cidr":"10.11.3.0/29"}' diff --git a/test/e2e/suite/51-l3vni.sh b/test/e2e/suite/51-l3vni.sh index 879e2cb..4e562f0 100644 --- a/test/e2e/suite/51-l3vni.sh +++ b/test/e2e/suite/51-l3vni.sh @@ -1,6 +1,6 @@ -# fonctionnalité: routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, démontage d'un VPC routé +# fonctionnalité: routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, unreachable default dans la VRF, démontage d'un VPC routé # hôtes: hv1 hv2 -# tickets: #41 +# tickets: #41, #81 on hv1 <<'NODE' KEY=$(vm_key) @@ -23,6 +23,9 @@ check "hv1 : vrf-t51 contient exactement brl3-t51 et l3-t51-o" sh -c "[ \"\$1\" check "hv1 : brl3-t51 sans adresse IPv4" sh -c "! ip -4 -o addr show dev brl3-t51 | grep -q inet" check "hv1 : RMAC de brl3-t51 dérivée du VTEP 192.168.14.11" sh -c "ip -o link show brl3-t51 | grep -q 'link/ether 02:02:c0:a8:0e:0b '" check "hv1 : route du supernet dans vp-t51 vers le transit" sh -c "ip -n vp-t51 -4 route show 10.51.0.0/18 | grep -q 'via 169.254.0.1 dev l3-t51-i'" +check "hv1 : table 5100 de vrf-t51 : unreachable default de métrique 4278198272" sh -c "ip -4 route show table 5100 | grep -q '^unreachable default metric 4278198272'" +check "hv1 : adresse du VPC inconnue (10.51.5.5) injoignable dans vrf-t51, pas de repli sur la table main" sh -c "ip -4 route get 10.51.5.5 vrf vrf-t51 2>&1 | grep -q 'No route to host'" +check "hv1 : adresse externe (8.8.8.8) injoignable dans vrf-t51" sh -c "ip -4 route get 8.8.8.8 vrf vrf-t51 2>&1 | grep -q 'No route to host'" check "hv1 : forwarding sur brl3-t51 et l3-t51-o" sh -c "[ \"\$(sysctl -n net.ipv4.conf.brl3-t51.forwarding net.ipv4.conf.l3-t51-o.forwarding | tr '\n' ' ')\" = '1 1 ' ]" check "hv1 : ip_forward dans le netns vp-t51" sh -c "[ \"\$(ip netns exec vp-t51 sysctl -n net.ipv4.ip_forward)\" = 1 ]" info "hv1 : ip_forward global de l'hôte : $(sysctl -n net.ipv4.ip_forward) (non modifié par l'agent)" @@ -41,6 +44,7 @@ check "hv2 : RMAC de hv1 dans la FDB de vxl3-t51" sh -c "bridge fdb show dev vxl NODE on rr1 <<'NODE' check "rr1 : RT-5 10.51.1.10/32 de hv1 (RD 192.168.14.11:5100) reçue et réfléchie" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.11:5100 type prefix' | grep -q '\[10.51.1.10\]'" +check "rr1 : aucune RT-5 0.0.0.0/0 de hv1 (RD 192.168.14.11:5100) : l'unreachable default n'est pas annoncée" sh -c "! vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.11:5100 type prefix' | grep -q '\[0.0.0.0\]'" check "rr1 : RT-5 10.51.2.20/32 de vp-t51b (RD 192.168.14.12:5101) présente (témoin du test négatif)" sh -c "vtysh -c 'show bgp l2vpn evpn route rd 192.168.14.12:5101 type prefix' | grep -q '\[10.51.2.20\]'" NODE on hv1 <<'NODE' @@ -56,6 +60,7 @@ check "TTL 2 : expire dans la VRF de hv1 (169.254.0.1)" vm_grep vp-t51 10.51.1.1 check "TTL 5 : atteint t51-b — quatre routeurs : gateway hv1, VRF hv1, VRF hv2, netns hv2" vm_ssh vp-t51 10.51.1.10 'ping -n -c 1 -W 2 -t 5 10.51.2.10' check "hv1 : vrf-t51 n'importe pas 10.51.2.20/32 de vp-t51b (RT 64600:5101)" sh -c "[ -z \"\$(ip -4 route show vrf vrf-t51 10.51.2.20)\" ]" check "t51-a ne joint pas t51-x, autre VPC, même plage" vm_fails vp-t51 10.51.1.10 'ping -c 3 -W 2 10.51.2.20' +check "t51-a vers une adresse inconnue du VPC (10.51.5.5) : refusé par vrf-t51 (169.254.0.1), rien vers l'underlay" vm_grep vp-t51 10.51.1.10 'ping -n -c 2 -W 2 10.51.5.5' 'From 169.254.0.1 .*Unreachable' NODE on hv2 <<'NODE' BGPD=$(pidof bgpd) @@ -64,9 +69,11 @@ check "hv2 : suppression de t51-x" vm_delete t51-x check "hv2 : vrf-t51b ne porte plus le /32 de t51-x" test -z "$(ip -4 route show vrf vrf-t51b 10.51.2.20/32)" check "hv2 : suppression de sn-t51x" api_delete subnets/sn-t51x check "hv2 : sn-t51x supprimé" wait_state subnets/sn-t51x deleted +check "hv2 : table 5101 de vrf-t51b : unreachable default avant le démontage (témoin)" sh -c "ip -4 route show table 5101 | grep -q '^unreachable default metric 4278198272'" check "hv2 : suppression de vp-t51b" api_delete vpcs/vp-t51b check "hv2 : vp-t51b supprimé" wait_state vpcs/vp-t51b deleted check "hv2 : plus aucune interface de vp-t51b" sh -c "! ip -o link show | grep -qE '(vrf|brl3|vxl3)-t51b|l3-t51b-o'" +check "hv2 : table 5101 vide après le démontage, unreachable default comprise" sh -c "! ip -4 route show table 5101 2>&1 | grep -qE '^(unreachable|default|[0-9])'" check "hv2 : plus rien de vrf-t51b dans FRR, en mémoire ni dans frr.conf" sh -c "! vtysh -c 'show running-config' | grep -q 'vrf-t51b' && ! grep -q 'vrf-t51b' /etc/frr/frr.conf" check "hv2 : bgpd n'a pas redémarré pendant le démontage" sh -c "[ \"\$(pidof bgpd)\" = '${BGPD}' ]" check "hv2 : vp-t51 toujours en service" wait_l3vni 5100 02:02:c0:a8:0e:0c diff --git a/test/e2e/suite/53-watchdog-l3.sh b/test/e2e/suite/53-watchdog-l3.sh index f0a6def..7d88c7e 100644 --- a/test/e2e/suite/53-watchdog-l3.sh +++ b/test/e2e/suite/53-watchdog-l3.sh @@ -1,6 +1,6 @@ -# fonctionnalité: watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais +# fonctionnalité: watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, unreachable default absente signalée, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais # hôtes: hv1 hv3 -# tickets: #41 +# tickets: #41, #81 on hv1 <<'NODE' check "hv1 : VPC vp-t53, l3vni 5300" vpc_create vp-t53 10.53.0.0/16 5300 @@ -28,6 +28,10 @@ check "watchdog : /32 de t53-m retiré à la main" ip route del 10.53.1.50/32 vr check "hypothèse du test : FRR retire le /32 de t53-m de sa table BGP quand la route du noyau disparaît" wait_bgp_paths vp-t53 10.53.1.50/32 0 check "watchdog : /32 manquant signalé" wait_watchdog "route 10.53.1.50/32 not exported in vrf-t53" check "watchdog : /32 de t53-m rétabli" ip route replace 10.53.1.50/32 via 169.254.0.2 dev l3-t53-o vrf vrf-t53 +check "watchdog : aucune alerte sur l'unreachable default avant son retrait (témoin)" watchdog_quiet_about 60 "no unreachable default" +check "watchdog : unreachable default retirée à la main de la table 5300" ip route del unreachable default metric 4278198272 table 5300 +check "watchdog : unreachable default absente signalée" wait_watchdog "no unreachable default in vrf-t53" +check "watchdog : unreachable default rétablie" ip route replace unreachable default metric 4278198272 table 5300 check "watchdog : aucune alerte BGP ni L3VNI sur hv1" watchdog_l3_quiet 60 NODE on hv3 <<'NODE' From 6d3d6314e21944b2d38f0af3e276a4b6d778dd28 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 11:53:58 +0100 Subject: [PATCH 06/17] f-81: doc: unreachable default, default_route, notes 0.3.0 #81 Signed-off-by: GnomeZworc --- docs/architecture/contraintes.rst | 7 +++++++ docs/concepts/modes-reseau.rst | 4 +++- docs/concepts/vpc-subnet-vm.rst | 16 +++++++++++++--- docs/developpement/lab.rst | 10 +++++----- docs/exploitation/observabilite.rst | 5 ++++- release_notes/0.3.0.md | 25 +++++++++++++++++++++++++ 6 files changed, 57 insertions(+), 10 deletions(-) create mode 100644 release_notes/0.3.0.md diff --git a/docs/architecture/contraintes.rst b/docs/architecture/contraintes.rst index 5686cee..dc1ca06 100644 --- a/docs/architecture/contraintes.rst +++ b/docs/architecture/contraintes.rst @@ -29,6 +29,13 @@ Réseau * **La route du subnet garde la gateway pour source** (``src``) : le netns parle à ses VM depuis la gateway, leurs réponses reviennent à l'hôte local. Depuis l'adresse d'émission, partagée par tous les hôtes, une réponse peut partir vers un autre hôte. +* **Chaque VRF de VPC porte une route ``unreachable default`` de métrique maximale.** Sans elle, + une recherche manquée dans la VRF retombe dans la table ``main`` de l'hôte et le paquet du + locataire sort par l'underlay. Elle survit à la suppression de la VRF (aucune interface) : la + retirer explicitement au démontage. +* **``default_route: true`` sans ``gateway`` est réservé au mode ``bridge``** : en ``vxlan``, la + gateway de l'hôte n'est pas sur le subnet, la route par défaut serait inutilisable, et jointe + elle contournerait le netns et la VRF. * ``169.254.169.254`` est centralisé dans ``metadata.ServiceIP`` — ne pas le réécrire en dur. QEMU et VM diff --git a/docs/concepts/modes-reseau.rst b/docs/concepts/modes-reseau.rst index 8a0503d..0e36516 100644 --- a/docs/concepts/modes-reseau.rst +++ b/docs/concepts/modes-reseau.rst @@ -172,7 +172,9 @@ seule. Le champ ``default_route`` ne choisit que son next-hop : ``default_route: true`` next-hop = le champ ``gateway`` s'il est fourni, sinon la gateway lue dans la table de routage - de l'host. + de l'host, à la création du subnet. Ce dernier cas est **réservé au mode** ``bridge``, où la VM + partage le L2 de cette gateway : sans ``gateway``, ``default_route: true`` est refusé (400) en + ``vxlan`` et en ``public_ip``. ``gateway`` n'est **pas validé** par l'agent : sa joignabilité et sa cohérence avec le CIDR du subnet relèvent de l'appelant. Fourni avec ``default_route: false``, il est ignoré. diff --git a/docs/concepts/vpc-subnet-vm.rst b/docs/concepts/vpc-subnet-vm.rst index 5156a38..0c9e850 100644 --- a/docs/concepts/vpc-subnet-vm.rst +++ b/docs/concepts/vpc-subnet-vm.rst @@ -44,7 +44,7 @@ subnets. L'agent n'impose que la première borne (le RD ``:`` porte .. code-block:: text - vrf- VRF, table de routage = l3vni + vrf- VRF, table de routage = l3vni, unreachable default metric 4278198272 ├── brl3- bridge sans adresse, MAC de routeur 02:02: │ └── vxl3- VXLAN du l3vni, VTEP = IPv4 primaire de default_interface └── l3--o 169.254.0.1/30 ── l3--i 169.254.0.2/30, dans le netns du VPC @@ -56,8 +56,18 @@ touche pas au réglage global, que ``bootstrap_kvm.sh`` met déjà à 1. FRR re ``router bgp vrf vrf-`` avec RD ``:`` et RT ``:``, et l'export des routes du ``cidr`` présentes dans la VRF. -La suppression retire d'abord la configuration de routage de FRR, puis les interfaces, puis la -VRF de FRR. Cet ordre est imposé : supprimer la VRF du noyau sous une instance BGP encore +La table de la VRF reçoit, juste après sa création, une route ``unreachable default`` de métrique +maximale (``4278198272``, valeur recommandée par la documentation VRF du noyau). Sans elle, une +recherche qui échoue dans la VRF continue dans les règles suivantes, donc dans la table ``main`` +de l'hôte : un paquet d'un locataire vers une adresse inconnue de la VRF sortirait par l'underlay, +avec ``169.254.0.2`` pour source (mesuré, `#81 `_). La +métrique maximale laisse passer avant elle toute route réelle de la VRF. Cette route n'est pas +annoncée en EVPN : le route-map de la VRF n'exporte que le ``cidr`` du VPC. Elle n'est liée à +aucune interface et ne disparaît pas avec la VRF : la suppression la retire explicitement. IPv4 +seulement. + +La suppression retire d'abord la configuration de routage de FRR, puis les interfaces, la route +``unreachable default``, puis la VRF de FRR. Cet ordre est imposé : supprimer la VRF du noyau sous une instance BGP encore configurée fait planter ``bgpd`` (FRR 10.7.1). Subnet diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index 632e03a..8296ed4 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -296,7 +296,7 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé * - ``11-validation`` - validation de l'API — refus synchrones (400, 409, 422) des VPC, subnets et VM, sans trace en base - hv1 - - #41, #57, #33, #62, #74 + - #41, #57, #33, #62, #74, #81 * - ``12-etats`` - machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom - hv1 @@ -370,17 +370,17 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé - hv1 hv2 - #57 * - ``51-l3vni`` - - routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, démontage d'un VPC routé + - routage inter-subnet entre hôtes par L3VNI (IRB symétrique) — VRF, RMAC, exports /24 et /32, RT-5 réfléchies, TTL, isolation par RT, unreachable default dans la VRF, démontage d'un VPC routé - hv1 hv2 - - #41 + - #41, #81 * - ``52-migration`` - migration d'une adresse de VM entre hôtes d'un VPC routé — /32 retiré en premier, /24 en filet puis en ECMP, séquence orchestrée, 40 sources, suppression du subnet refusée tant qu'une VM l'utilise, MAC anycast hors EVPN - hv1 hv2 hv3 - #41, #57 * - ``53-watchdog-l3`` - - watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais + - watchdog d'un VPC routé — /32 orphelin signalé comme trou noir, /32 manquant signalé, unreachable default absente signalée, aucune fausse alerte BGP ni L3VNI, trafic intact après les essais - hv1 hv3 - - #41 + - #41, #81 * - ``61-redemarrage-agent`` - redémarrage de l'agent avec des VM en marche — rien ne disparaît ni n'est recréé, trafic routé sans perte, DHCP et métadonnées servis, base BGP réappliquée à l'identique, ressources toujours gérées - hv1 hv2 diff --git a/docs/exploitation/observabilite.rst b/docs/exploitation/observabilite.rst index 46d1a37..34c1197 100644 --- a/docs/exploitation/observabilite.rst +++ b/docs/exploitation/observabilite.rst @@ -45,7 +45,10 @@ Avec une section ``bgp`` dans la configuration, il contrôle aussi le plan de co ``Established`` (``show bgp neighbors ``). * **VPC routés** (``l3vni``, état ``running``) : présence et état des interfaces ``vrf-``, ``brl3-``, ``vxl3-``, ``l3--o`` et, dans le netns, ``l3--i`` ; L3VNI de type - ``L3``, ``Up``, avec la MAC de routeur attendue (``show evpn vni ``). + ``L3``, ``Up``, avec la MAC de routeur attendue (``show evpn vni ``) ; route + ``unreachable default`` de métrique ``4278198272`` dans la table de la VRF. Un VPC routé créé + par une version antérieure à la 0.3.0 ne l'a pas : il est signalé à chaque tick jusqu'à sa + recréation, l'agent ne la pose pas au démarrage. * **Réconciliation des routes exportées** dans la VRF : chaque ``/24`` de subnet ``vxlan`` et chaque ``/32`` d'interface de VM ``running`` doit être exporté ; à l'inverse, une route exportée dont le propriétaire n'existe plus — ni ``running``, ni en ``creating``, ``deleting`` ou ``error`` — diff --git a/release_notes/0.3.0.md b/release_notes/0.3.0.md new file mode 100644 index 0000000..baca9d6 --- /dev/null +++ b/release_notes/0.3.0.md @@ -0,0 +1,25 @@ +# Gabriel + +## Correctifs + +- **Chaque VRF de VPC porte une route `unreachable default` (#81).** Une recherche qui échouait + dans la table d'une VRF continuait dans la table `main` de l'hôte : un paquet d'un locataire + vers une adresse inconnue de son VPC sortait par l'underlay, avec `169.254.0.2` pour source + (mesuré en lab). La route est posée juste après la VRF, avec la métrique maximale + `4278198272`, de sorte que toute route réelle reste prioritaire ; elle n'est pas annoncée en + EVPN et elle est retirée au démontage du VPC. Le watchdog signale une VRF qui ne l'a pas. + IPv4 seulement +- **`default_route: true` sans `gateway` est réservé au mode `bridge` (#81)** : refusé (400) en + `vxlan` et en `public_ip`. Hors `bridge`, la gateway lue dans la table de routage de l'hôte + n'est pas sur le subnet des VM : la route par défaut annoncée était inutilisable + +## Mise à jour depuis la 0.2.0 + +- **`default_route: true` exige une `gateway` hors mode `bridge`** : un appel qui l'omettait en + `vxlan` reçoit désormais un 400. Les subnets existants gardent la route par défaut qu'ils + annonçaient jusqu'à leur recréation +- **Les VPC routés existants n'ont pas la route `unreachable default`** : l'agent ne la pose pas + au démarrage, le watchdog les signale à chaque tick. La recréation du VPC la pose ; d'ici là, + la fuite vers l'underlay décrite plus haut reste possible. Pour la fermer sans recréer le VPC, + la poser à la main sur chaque hyperviseur, la table étant le `l3vni` du VPC : + `ip route replace unreachable default metric 4278198272 table ` From 91c0cc03d5b47affc4075f0adc119691d9bc86fe Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 19:19:45 +0100 Subject: [PATCH 07/17] f-87: e2e: advertise-default-gw sur les bordures, gateway en type 2 #87 Signed-off-by: GnomeZworc --- docs/developpement/lab.rst | 15 ++++++++++----- test/e2e/topologies/frr/bd1.conf | 1 + test/e2e/topologies/frr/bd2.conf | 1 + 3 files changed, 12 insertions(+), 5 deletions(-) diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index c292ed3..323c66c 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -133,11 +133,16 @@ routeurs de bordure du segment public. Ce sont des nœuds ``host`` sans agent : (VNI 66001, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:01:01:d1`` (la MAC anycast de two pour le VNI 66001), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface -``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur : iBGP AS 64600 vers les -deux route reflectors, ``advertise-all-vni``. Les adresses publiques du lab sont prises dans -``240.0.0.0/4``, réservée (RFC 1112, registre RFC 6890) et jamais routée sur Internet. Les bordures -sont déclarées après les hyperviseurs : les adresses et les taps de l'underlay ne changent pas, -ceux du segment ``lan`` sont renumérotés. +``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur — iBGP AS 64600 vers les +deux route reflectors, ``advertise-all-vni`` — plus ``advertise-default-gw`` : la MAC et l'IP +de la gateway sont annoncées en type 2 avec la communauté *Default Gateway* (RFC 7432, §7.8 et +§10.1). Sans elle, la MAC propre du bridge n'est pas annoncée, les hyperviseurs inondent le +trafic vers tous les VTEP et les deux bordures répondent ; avec elle, chaque hyperviseur installe +la MAC vers une seule bordure et bascule sur l'autre quand elle disparaît (mesuré le 2026-10-25, +#87). Les adresses publiques du lab sont prises dans ``240.0.0.0/4``, réservée (RFC 1112, +registre RFC 6890) et jamais routée sur Internet. Les bordures sont déclarées après les +hyperviseurs : les adresses et les taps de l'underlay ne changent pas, ceux du segment ``lan`` +sont renumérotés. **Tester l'arbre courant plutôt que la release.** ``test/e2e/build.sh`` compile ``agent``, ``dhcp`` et ``metadata`` pour linux/amd64 dans ``test/e2e/topologies/bin/`` (ignoré par git), diff --git a/test/e2e/topologies/frr/bd1.conf b/test/e2e/topologies/frr/bd1.conf index 0a3d79c..71143c2 100644 --- a/test/e2e/topologies/frr/bd1.conf +++ b/test/e2e/topologies/frr/bd1.conf @@ -14,6 +14,7 @@ router bgp 64600 address-family l2vpn evpn neighbor fabric activate advertise-all-vni + advertise-default-gw exit-address-family exit ! diff --git a/test/e2e/topologies/frr/bd2.conf b/test/e2e/topologies/frr/bd2.conf index e1ce95a..71ccb61 100644 --- a/test/e2e/topologies/frr/bd2.conf +++ b/test/e2e/topologies/frr/bd2.conf @@ -14,6 +14,7 @@ router bgp 64600 address-family l2vpn evpn neighbor fabric activate advertise-all-vni + advertise-default-gw exit-address-family exit ! From 0d4dc9fd91e23a248da4e20aca8aea79e3ab1780 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 12:10:32 +0100 Subject: [PATCH 08/17] =?UTF-8?q?f-84:=20vm:=20sockets=20QEMU=20retir?= =?UTF-8?q?=C3=A9s=20=C3=A0=20la=20suppression=20d'une=20VM=20#84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GnomeZworc --- internal/vm/delete.go | 16 +++++++ internal/vm/delete_test.go | 86 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 102 insertions(+) create mode 100644 internal/vm/delete_test.go diff --git a/internal/vm/delete.go b/internal/vm/delete.go index 304a75d..06d3658 100644 --- a/internal/vm/delete.go +++ b/internal/vm/delete.go @@ -1,7 +1,9 @@ package vm import ( + "errors" "fmt" + "io/fs" "os" "path/filepath" "time" @@ -57,6 +59,10 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { } // socket absent ou QEMU déjà arrêté : cleanup direct + if err := removeQEMUSockets(cfg, name); err != nil { + return err + } + if err := netns.Call(nic.vpcName, func() error { for _, n := range d.nics { if err := iptables.DeleteMetadataRedirect(n.ip, nic.interfaceIP, d.metadataPort); err != nil { @@ -90,6 +96,16 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { return state.Set(db, "vm/"+name, state.Deleted) } +func removeQEMUSockets(cfg *configuration.Config, name string) error { + for _, dir := range []string{cfg.QEMU.SerialDir, cfg.QEMU.MonitorDir, cfg.QEMU.QMPDir} { + path := filepath.Join(dir, name+".sock") + if err := os.Remove(path); err != nil && !errors.Is(err, fs.ErrNotExist) { + return fmt.Errorf("remove qemu socket: %w", err) + } + } + return nil +} + func removeDHCPFiles(d vmData, name string, backend dhcpbackend.Backend) error { for _, f := range dhcpReservations(d) { if err := backend.DelVM(f.subnet, name, f.reservations); err != nil { diff --git a/internal/vm/delete_test.go b/internal/vm/delete_test.go new file mode 100644 index 0000000..d296f68 --- /dev/null +++ b/internal/vm/delete_test.go @@ -0,0 +1,86 @@ +package vm + +import ( + "os" + "path/filepath" + "strings" + "testing" + + configuration "git.g3e.fr/syonad/two/internal/config/agent" +) + +func socketDirs(t *testing.T) *configuration.Config { + t.Helper() + root, err := os.MkdirTemp("", "sock") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { os.RemoveAll(root) }) + cfg := &configuration.Config{} + cfg.QEMU.SerialDir = filepath.Join(root, "serial") + cfg.QEMU.MonitorDir = filepath.Join(root, "monitor") + cfg.QEMU.QMPDir = filepath.Join(root, "qmp") + for _, dir := range []string{cfg.QEMU.SerialDir, cfg.QEMU.MonitorDir, cfg.QEMU.QMPDir} { + if err := os.Mkdir(dir, 0755); err != nil { + t.Fatal(err) + } + } + return cfg +} + +func leave(t *testing.T, path string) { + t.Helper() + if err := os.WriteFile(path, nil, 0600); err != nil { + t.Fatal(err) + } +} + +func TestRemoveQEMUSockets_RemovesTheThreeSocketsOfTheVM(t *testing.T) { + cfg := socketDirs(t) + sockets := []string{ + filepath.Join(cfg.QEMU.SerialDir, "t12-err.sock"), + filepath.Join(cfg.QEMU.MonitorDir, "t12-err.sock"), + filepath.Join(cfg.QEMU.QMPDir, "t12-err.sock"), + } + for _, s := range sockets { + leave(t, s) + } + other := filepath.Join(cfg.QEMU.MonitorDir, "t12-ok.sock") + leave(t, other) + + if err := removeQEMUSockets(cfg, "t12-err"); err != nil { + t.Fatal(err) + } + for _, s := range sockets { + if _, err := os.Lstat(s); !os.IsNotExist(err) { + t.Errorf("%s laissé (%v)", s, err) + } + } + if _, err := os.Lstat(other); err != nil { + t.Errorf("socket d'une autre VM retiré : %v", err) + } +} + +func TestRemoveQEMUSockets_AbsentSocketsAreNotAnError(t *testing.T) { + cfg := socketDirs(t) + leave(t, filepath.Join(cfg.QEMU.MonitorDir, "t12-err.sock")) + if err := removeQEMUSockets(cfg, "t12-err"); err != nil { + t.Errorf("sockets serial et qmp absents : %v", err) + } + if err := removeQEMUSockets(cfg, "t12-err"); err != nil { + t.Errorf("second passage : %v", err) + } +} + +func TestRemoveQEMUSockets_ReportsAFailedRemoval(t *testing.T) { + cfg := socketDirs(t) + blocked := filepath.Join(cfg.QEMU.QMPDir, "t12-err.sock") + if err := os.Mkdir(blocked, 0755); err != nil { + t.Fatal(err) + } + leave(t, filepath.Join(blocked, "x")) + err := removeQEMUSockets(cfg, "t12-err") + if err == nil || !strings.Contains(err.Error(), "remove qemu socket") || !strings.Contains(err.Error(), blocked) { + t.Errorf("erreur %v, attendu l'échec de suppression de %s", err, blocked) + } +} From de639667ed618f5315a99267ef0b5db576466b85 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 12:10:37 +0100 Subject: [PATCH 09/17] =?UTF-8?q?f-84:=20e2e:=2012-etats,=20aucun=20socket?= =?UTF-8?q?=20QEMU=20laiss=C3=A9=20par=20t12-err=20#84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GnomeZworc --- test/e2e/suite/12-etats.sh | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/test/e2e/suite/12-etats.sh b/test/e2e/suite/12-etats.sh index aab8d3e..5edf9f3 100644 --- a/test/e2e/suite/12-etats.sh +++ b/test/e2e/suite/12-etats.sh @@ -1,6 +1,6 @@ -# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom +# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, recréation sous le même nom # hôtes: hv1 -# tickets: #41 +# tickets: #41, #84 on hv1 <<'NODE' check "VPC vp-t12a" vpc_create vp-t12a 10.12.0.0/16 @@ -23,8 +23,11 @@ check "suppression d'un VPC inconnu, 404" expect_code 404 api_code DELETE vpcs/v check "VM t12-err sur un disque absent : acceptée, 202 (pas de refus synchrone)" expect_code 202 api_post_code vms "$(vm_body t12-err sn-t12a 10.12.1.11 "${VOLUMES}/t12-absent.qcow2")" check "t12-err passe en error" wait_state vms/t12-err error +info "t12-err : sockets laissés par QEMU : $(ls /run/two/vms/serial/t12-err.sock /run/two/vms/monitor/t12-err.sock /run/two/vms/qmp/t12-err.sock 2>&1 | tr '\n' ' ')" +check "t12-err : les trois sockets QEMU posés à la main s'ils manquent" sh -c 'for d in serial monitor qmp; do [ -e "/run/two/vms/${d}/t12-err.sock" ] || : > "/run/two/vms/${d}/t12-err.sock" || exit 1; done' check "suppression de t12-err depuis error, 202" expect_code 202 api_code DELETE vms/t12-err check "t12-err supprimée" wait_state vms/t12-err deleted +check "t12-err : aucun socket QEMU laissé dans /run/two/vms" sh -c 'for d in serial monitor qmp; do [ ! -e "/run/two/vms/${d}/t12-err.sock" ] || { echo "/run/two/vms/${d}/t12-err.sock laissé"; exit 1; }; done' check "t12-err : aucune unité two-vm-t12-err" sh -c '! systemctl list-units --all --plain --no-legend "two-vm-t12-err*" | grep -q .' check "suppression de t12-a" vm_delete t12-a From 62edefee5a54b77f75000edb0dcb01f7e1efb406 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 12:10:40 +0100 Subject: [PATCH 10/17] =?UTF-8?q?f-84:=20doc:=20sockets=20QEMU=20retir?= =?UTF-8?q?=C3=A9s=20=C3=A0=20la=20suppression,=20notes=200.3.0=20#84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GnomeZworc --- docs/developpement/lab.rst | 4 ++-- docs/exploitation/services.rst | 4 ++++ release_notes/0.3.0.md | 4 ++++ 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index 8296ed4..7574ab2 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -298,9 +298,9 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé - hv1 - #41, #57, #33, #62, #74, #81 * - ``12-etats`` - - machine d'états — 409 pendant creating, suppression depuis error, dépendances VM → subnet → VPC, recréation sous le même nom + - machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, recréation sous le même nom - hv1 - - #41 + - #41, #84 * - ``21-dhcp-two`` - DHCP par le serveur intégré (backend two) — bail, server-id, renouvellement, option 121, un serveur par subnet, démarrages simultanés - hv1 diff --git a/docs/exploitation/services.rst b/docs/exploitation/services.rst index d6ff8f7..1ae0b15 100644 --- a/docs/exploitation/services.rst +++ b/docs/exploitation/services.rst @@ -117,6 +117,10 @@ Sockets par VM /run/two/vms/monitor/.sock monitor QEMU /run/two/vms/qmp/.sock QMP (utilisé par l'agent) +QEMU les crée au démarrage et les retire en quittant normalement. La suppression d'une VM les +retire aussi, une fois QEMU arrêté : un QEMU qui échoue au démarrage (disque absent) peut les +laisser derrière lui. + .. code-block:: bash socat -,raw,echo=0 UNIX-CONNECT:/run/two/vms/serial/i-web.sock diff --git a/release_notes/0.3.0.md b/release_notes/0.3.0.md index baca9d6..ad63707 100644 --- a/release_notes/0.3.0.md +++ b/release_notes/0.3.0.md @@ -12,6 +12,10 @@ - **`default_route: true` sans `gateway` est réservé au mode `bridge` (#81)** : refusé (400) en `vxlan` et en `public_ip`. Hors `bridge`, la gateway lue dans la table de routage de l'hôte n'est pas sur le subnet des VM : la route par défaut annoncée était inutilisable +- **La suppression d'une VM retire ses sockets QEMU (#84).** Quand QEMU échouait au démarrage + (disque absent par exemple), il pouvait laisser `.sock` dans `serial_dir`, `monitor_dir` ou + `qmp_dir`, que la suppression de la VM ne retirait pas. Les trois sont désormais supprimés une + fois QEMU arrêté ; un fichier absent n'est pas une erreur ## Mise à jour depuis la 0.2.0 From e6c758af78f72d22d60441c4a9f1a6426af9e876 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 12:42:10 +0100 Subject: [PATCH 11/17] f-79: agent: section times, renvoi de system_powerdown, attentes #79 Signed-off-by: GnomeZworc --- api/agent.yaml | 4 +- conf/agent/config.exemple.yml | 22 ++- internal/config/agent/struct.go | 17 +- internal/config/agent/times.go | 64 +++++++ internal/config/agent/times_test.go | 95 ++++++++++ internal/dispatcher/agent/subnet_commands.go | 61 +++++-- .../dispatcher/agent/subnet_commands_test.go | 2 +- internal/dispatcher/agent/vm_commands.go | 26 +-- internal/dispatcher/agent/vpc_commands.go | 60 ++++--- internal/dispatcher/agent/wait.go | 26 +++ internal/dispatcher/agent/wait_test.go | 168 ++++++++++++++++++ internal/vm/delete.go | 35 ++-- internal/vm/shutdown_test.go | 102 +++++++++++ 13 files changed, 602 insertions(+), 80 deletions(-) create mode 100644 internal/config/agent/times.go create mode 100644 internal/config/agent/times_test.go create mode 100644 internal/dispatcher/agent/wait.go create mode 100644 internal/dispatcher/agent/wait_test.go create mode 100644 internal/vm/shutdown_test.go diff --git a/api/agent.yaml b/api/agent.yaml index 1f0b7bb..40e0400 100644 --- a/api/agent.yaml +++ b/api/agent.yaml @@ -91,7 +91,7 @@ paths: "404": $ref: "#/components/responses/NotFound" "409": - description: VPC not deletable — only running or error states can be deleted, and all its subnets must be deleted first + description: VPC not deletable — only running or error states can be deleted, and all its subnets must be deleted or deleting; subnets still deleting are awaited by the asynchronous deletion content: application/json: schema: @@ -289,7 +289,7 @@ paths: "404": $ref: "#/components/responses/NotFound" "409": - description: Subnet not deletable — only running or error states can be deleted, and no VM that is not deleted may still have an interface on it + description: Subnet not deletable — only running or error states can be deleted, and every VM with an interface on it must be deleted or deleting; VMs still deleting are awaited by the asynchronous deletion content: application/json: schema: diff --git a/conf/agent/config.exemple.yml b/conf/agent/config.exemple.yml index 3d95b94..e03bc6e 100644 --- a/conf/agent/config.exemple.yml +++ b/conf/agent/config.exemple.yml @@ -19,12 +19,22 @@ worker: # Maximum number of commands queued before Dispatch blocks buffer_size: 100 -# Timing for commands that wait on resource state transitions -dispatcher: - # How long (in seconds) to wait before giving up - timeout_seconds: 300 - # Interval (in seconds) between each state check - poll_seconds: 2 +# Timing (in seconds) for commands that wait on resource state transitions +times: + # Graceful VM shutdown before QMP quit + timeout_vms_stop: 300 + # Interval between two system_powerdown during the shutdown + next_vms_shutdown: 30 + # Subnet deletion: wait for its VMs still deleting + timeout_subnet_stop: 360 + # VPC deletion: wait for its subnets still deleting + timeout_vpc_stop: 420 + # Subnet creation: wait for its VPC to be running + timeout_subnet_start: 300 + # VM creation: wait for the subnets of its interfaces to be running + timeout_vms_start: 300 + # Interval between each state check + poll_interval: 2 # Bridge interface used when the requested iface_type is not found in interfaces default_interface: br-000000 diff --git a/internal/config/agent/struct.go b/internal/config/agent/struct.go index 1381d2f..3de53cb 100644 --- a/internal/config/agent/struct.go +++ b/internal/config/agent/struct.go @@ -24,10 +24,7 @@ type Config struct { Count int `mapstructure:"count"` BufferSize int `mapstructure:"buffer_size"` } `mapstructure:"worker"` - Dispatcher struct { - TimeoutSeconds int `mapstructure:"timeout_seconds"` - PollSeconds int `mapstructure:"poll_seconds"` - } `mapstructure:"dispatcher"` + Times Times `mapstructure:"times"` Logger struct { Level string `mapstructure:"level"` Debug bool `mapstructure:"debug"` @@ -73,8 +70,13 @@ func LoadConfig(path string) (*Config, error) { v.SetDefault("prometheus.port", 9090) v.SetDefault("worker.count", 4) v.SetDefault("worker.buffer_size", 100) - v.SetDefault("dispatcher.timeout_seconds", 300) - v.SetDefault("dispatcher.poll_seconds", 2) + v.SetDefault("times.timeout_vms_stop", TimeoutVMsStop) + v.SetDefault("times.next_vms_shutdown", NextVMsShutdown) + v.SetDefault("times.timeout_subnet_stop", TimeoutSubnetStop) + v.SetDefault("times.timeout_vpc_stop", TimeoutVPCStop) + v.SetDefault("times.timeout_subnet_start", TimeoutSubnetStart) + v.SetDefault("times.timeout_vms_start", TimeoutVMsStart) + v.SetDefault("times.poll_interval", PollInterval) v.SetDefault("metadata.run_dir", "/run/two/metadata") v.SetDefault("dhcp.backend", BackendTwo) v.SetDefault("qemu.ovmf_code_path", "/usr/share/OVMF/OVMF_CODE.fd") @@ -106,6 +108,9 @@ func LoadConfig(path string) (*Config, error) { if err := cfg.Network.Validate(); err != nil { return nil, fmt.Errorf("%s: %w", path, err) } + if err := cfg.Times.Validate(); err != nil { + return nil, fmt.Errorf("%s: %w", path, err) + } return &cfg, nil } diff --git a/internal/config/agent/times.go b/internal/config/agent/times.go new file mode 100644 index 0000000..c482029 --- /dev/null +++ b/internal/config/agent/times.go @@ -0,0 +1,64 @@ +package configuration + +import ( + "fmt" + "time" +) + +const ( + TimeoutVMsStop = 300 + NextVMsShutdown = 30 + TimeoutSubnetStop = 360 + TimeoutVPCStop = 420 + TimeoutSubnetStart = 300 + TimeoutVMsStart = 300 + PollInterval = 2 +) + +type Times struct { + TimeoutVMsStop int `mapstructure:"timeout_vms_stop"` + NextVMsShutdown int `mapstructure:"next_vms_shutdown"` + TimeoutSubnetStop int `mapstructure:"timeout_subnet_stop"` + TimeoutVPCStop int `mapstructure:"timeout_vpc_stop"` + TimeoutSubnetStart int `mapstructure:"timeout_subnet_start"` + TimeoutVMsStart int `mapstructure:"timeout_vms_start"` + PollInterval int `mapstructure:"poll_interval"` +} + +func seconds(value, fallback int) time.Duration { + if value == 0 { + value = fallback + } + return time.Duration(value) * time.Second +} + +func (t Times) VMsStop() time.Duration { return seconds(t.TimeoutVMsStop, TimeoutVMsStop) } +func (t Times) VMsShutdown() time.Duration { return seconds(t.NextVMsShutdown, NextVMsShutdown) } +func (t Times) SubnetStop() time.Duration { return seconds(t.TimeoutSubnetStop, TimeoutSubnetStop) } +func (t Times) VPCStop() time.Duration { return seconds(t.TimeoutVPCStop, TimeoutVPCStop) } +func (t Times) SubnetStart() time.Duration { return seconds(t.TimeoutSubnetStart, TimeoutSubnetStart) } +func (t Times) VMsStart() time.Duration { return seconds(t.TimeoutVMsStart, TimeoutVMsStart) } +func (t Times) Poll() time.Duration { return seconds(t.PollInterval, PollInterval) } + +func (t Times) Validate() error { + for _, f := range []struct { + key string + value int + }{ + {"timeout_vms_stop", t.TimeoutVMsStop}, + {"next_vms_shutdown", t.NextVMsShutdown}, + {"timeout_subnet_stop", t.TimeoutSubnetStop}, + {"timeout_vpc_stop", t.TimeoutVPCStop}, + {"timeout_subnet_start", t.TimeoutSubnetStart}, + {"timeout_vms_start", t.TimeoutVMsStart}, + {"poll_interval", t.PollInterval}, + } { + if f.value <= 0 { + return fmt.Errorf("times.%s %d must be a positive number of seconds", f.key, f.value) + } + } + if t.NextVMsShutdown >= t.TimeoutVMsStop { + return fmt.Errorf("times.next_vms_shutdown %d must be below times.timeout_vms_stop %d", t.NextVMsShutdown, t.TimeoutVMsStop) + } + return nil +} diff --git a/internal/config/agent/times_test.go b/internal/config/agent/times_test.go new file mode 100644 index 0000000..b35330c --- /dev/null +++ b/internal/config/agent/times_test.go @@ -0,0 +1,95 @@ +package configuration + +import ( + "strings" + "testing" + "time" +) + +func TestLoadConfig_TimesDefauts(t *testing.T) { + cfg, err := LoadConfig(writeYAML(t, "")) + if err != nil { + t.Fatalf("LoadConfig a échoué : %v", err) + } + want := Times{ + TimeoutVMsStop: 300, + NextVMsShutdown: 30, + TimeoutSubnetStop: 360, + TimeoutVPCStop: 420, + TimeoutSubnetStart: 300, + TimeoutVMsStart: 300, + PollInterval: 2, + } + if cfg.Times != want { + t.Errorf("times par défaut : %+v, attendu %+v", cfg.Times, want) + } +} + +func TestLoadConfig_TimesValeursExplicites(t *testing.T) { + cfg, err := LoadConfig(writeYAML(t, "times:\n timeout_vms_stop: 600\n next_vms_shutdown: 10\n timeout_subnet_stop: 700\n timeout_vpc_stop: 800\n timeout_subnet_start: 50\n timeout_vms_start: 60\n poll_interval: 1\n")) + if err != nil { + t.Fatalf("LoadConfig a échoué : %v", err) + } + want := Times{600, 10, 700, 800, 50, 60, 1} + if cfg.Times != want { + t.Errorf("times : %+v, attendu %+v", cfg.Times, want) + } +} + +func TestLoadConfig_AncienneSectionDispatcherIgnoree(t *testing.T) { + cfg, err := LoadConfig(writeYAML(t, "dispatcher:\n timeout_seconds: 900\n poll_seconds: 7\n")) + if err != nil { + t.Fatalf("une section dispatcher restante ne doit pas empêcher le démarrage : %v", err) + } + if cfg.Times.TimeoutVMsStop != 300 || cfg.Times.PollInterval != 2 { + t.Errorf("dispatcher.* ne doit rien changer : %+v", cfg.Times) + } +} + +func TestLoadConfig_TimesInvalidesRefuses(t *testing.T) { + for _, c := range []struct{ yaml, msg string }{ + {"times:\n timeout_vms_stop: 0\n", "times.timeout_vms_stop 0 must be a positive number of seconds"}, + {"times:\n next_vms_shutdown: -1\n", "times.next_vms_shutdown -1 must be a positive number of seconds"}, + {"times:\n timeout_subnet_stop: 0\n", "times.timeout_subnet_stop 0"}, + {"times:\n timeout_vpc_stop: 0\n", "times.timeout_vpc_stop 0"}, + {"times:\n timeout_subnet_start: 0\n", "times.timeout_subnet_start 0"}, + {"times:\n timeout_vms_start: 0\n", "times.timeout_vms_start 0"}, + {"times:\n poll_interval: 0\n", "times.poll_interval 0"}, + {"times:\n next_vms_shutdown: 300\n", "times.next_vms_shutdown 300 must be below times.timeout_vms_stop 300"}, + } { + if _, err := LoadConfig(writeYAML(t, c.yaml)); err == nil || !strings.Contains(err.Error(), c.msg) { + t.Errorf("%q : erreur %v, attendu %q", c.yaml, err, c.msg) + } + } + if _, err := LoadConfig(writeYAML(t, "times:\n next_vms_shutdown: 299\n")); err != nil { + t.Errorf("next_vms_shutdown 299 sous timeout_vms_stop 300 : %v", err) + } +} + +func TestTimesDurees(t *testing.T) { + var zero Times + cases := []struct { + name string + got, want time.Duration + }{ + {"VMsStop", zero.VMsStop(), 300 * time.Second}, + {"VMsShutdown", zero.VMsShutdown(), 30 * time.Second}, + {"SubnetStop", zero.SubnetStop(), 360 * time.Second}, + {"VPCStop", zero.VPCStop(), 420 * time.Second}, + {"SubnetStart", zero.SubnetStart(), 300 * time.Second}, + {"VMsStart", zero.VMsStart(), 300 * time.Second}, + {"Poll", zero.Poll(), 2 * time.Second}, + } + for _, c := range cases { + if c.got != c.want { + t.Errorf("Times{}.%s() = %v, attendu %v", c.name, c.got, c.want) + } + } + set := Times{11, 12, 13, 14, 15, 16, 17} + got := []time.Duration{set.VMsStop(), set.VMsShutdown(), set.SubnetStop(), set.VPCStop(), set.SubnetStart(), set.VMsStart(), set.Poll()} + for i, d := range got { + if want := time.Duration(11+i) * time.Second; d != want { + t.Errorf("durée %d = %v, attendu %v", i, d, want) + } + } +} diff --git a/internal/dispatcher/agent/subnet_commands.go b/internal/dispatcher/agent/subnet_commands.go index d97de05..91f08bc 100644 --- a/internal/dispatcher/agent/subnet_commands.go +++ b/internal/dispatcher/agent/subnet_commands.go @@ -1,6 +1,7 @@ package dispatcher import ( + "errors" "fmt" "sort" "strconv" @@ -93,23 +94,21 @@ func (c CreateSubnetCommand) Prepare(db *badger.DB, cfg *configuration.Config) e } func (c CreateSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error { - timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second) - for { + err := waitUntil(cfg.Times.SubnetStart(), cfg.Times.Poll(), func() (bool, error) { vpcState, err := state.Get(db, "vpc/"+c.VPC) if err != nil { - return fmt.Errorf("vpc %q not found while waiting", c.VPC) + return false, fmt.Errorf("vpc %q not found while waiting", c.VPC) } - if vpcState == state.Running { - break - } - if vpcState != state.Creating { - return fmt.Errorf("vpc %q is %s, cannot create subnet %q", c.VPC, vpcState, c.Name) - } - select { - case <-timeout: - return fmt.Errorf("timed out waiting for vpc %q to be running", c.VPC) - case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second): + if vpcState != state.Running && vpcState != state.Creating { + return false, fmt.Errorf("vpc %q is %s, cannot create subnet %q", c.VPC, vpcState, c.Name) } + return vpcState == state.Running, nil + }) + if errors.Is(err, errWaitTimeout) { + return fmt.Errorf("timed out waiting for vpc %q to be running", c.VPC) + } + if err != nil { + return err } return subnet.CreateSubnet(db, c.Name, cfg) } @@ -132,12 +131,41 @@ func (c DeleteSubnetCommand) Prepare(db *badger.DB, _ *configuration.Config) err if err != nil { return err } - if len(vms) > 0 { - return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(vms, ", ")) + var blocking []string + for _, name := range vms { + if s, err := state.Get(db, "vm/"+name); err != nil || s != state.Deleting { + blocking = append(blocking, name) + } + } + if len(blocking) > 0 { + return fmt.Errorf("subnet %q is still used by vms %s", c.Name, strings.Join(blocking, ", ")) } return state.Set(db, c.Key(), state.Deleting) } +func waitVMsDeleted(db *badger.DB, subnetName string, timeout, poll time.Duration) error { + err := waitUntil(timeout, poll, func() (bool, error) { + vms, err := vmsUsingSubnet(db, subnetName) + if err != nil { + return false, err + } + for _, name := range vms { + s, err := state.Get(db, "vm/"+name) + if err != nil { + continue + } + if s != state.Deleting { + return false, fmt.Errorf("vm %q is %s, subnet %q cannot be deleted", name, s, subnetName) + } + } + return len(vms) == 0, nil + }) + if errors.Is(err, errWaitTimeout) { + return fmt.Errorf("timed out waiting for the vms of subnet %q to be deleted", subnetName) + } + return err +} + func vmsUsingSubnet(db *badger.DB, subnetName string) ([]string, error) { entries, err := kv.ListByPrefix(db, "vm/") if err != nil { @@ -159,6 +187,9 @@ func vmsUsingSubnet(db *badger.DB, subnetName string) ([]string, error) { } func (c DeleteSubnetCommand) Execute(db *badger.DB, cfg *configuration.Config) error { + if err := waitVMsDeleted(db, c.Name, cfg.Times.SubnetStop(), cfg.Times.Poll()); err != nil { + return err + } if err := subnet.DeleteSubnet(db, c.Name, cfg); err != nil { return err } diff --git a/internal/dispatcher/agent/subnet_commands_test.go b/internal/dispatcher/agent/subnet_commands_test.go index d9095f2..a2d6cd5 100644 --- a/internal/dispatcher/agent/subnet_commands_test.go +++ b/internal/dispatcher/agent/subnet_commands_test.go @@ -418,7 +418,7 @@ func TestDeleteSubnetCommand_Prepare_RefusedWhileAVMUsesIt(t *testing.T) { kv.AddInDB(db, "vm/i-c/state", "running") kv.AddInDB(db, "vm/i-c/nic/0/subnet", "sn-a") err := DeleteSubnetCommand{Name: "sn-a"}.Prepare(db, nil) - if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-b, i-c`) { + if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-c`) { t.Fatalf("erreur %v", err) } if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "running" { diff --git a/internal/dispatcher/agent/vm_commands.go b/internal/dispatcher/agent/vm_commands.go index 3bdd7ee..bcd8b61 100644 --- a/internal/dispatcher/agent/vm_commands.go +++ b/internal/dispatcher/agent/vm_commands.go @@ -1,6 +1,7 @@ package dispatcher import ( + "errors" "fmt" "math/rand" "strconv" @@ -151,24 +152,23 @@ func allocateMetadataPort(db *badger.DB) (int, error) { } func (c StartVMCommand) Execute(db *badger.DB, cfg *configuration.Config) error { - timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second) + timeout := time.Now().Add(cfg.Times.VMsStart()) for _, n := range c.NICs { - for { + err := waitUntil(time.Until(timeout), cfg.Times.Poll(), func() (bool, error) { subnetState, err := state.Get(db, "subnet/"+n.Subnet) if err != nil { - return fmt.Errorf("subnet %q not found while waiting", n.Subnet) + return false, fmt.Errorf("subnet %q not found while waiting", n.Subnet) } - if subnetState == state.Running { - break - } - if subnetState != state.Creating { - return fmt.Errorf("subnet %q is %s, cannot start vm %q", n.Subnet, subnetState, c.Name) - } - select { - case <-timeout: - return fmt.Errorf("timed out waiting for subnet %q to be running", n.Subnet) - case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second): + if subnetState != state.Running && subnetState != state.Creating { + return false, fmt.Errorf("subnet %q is %s, cannot start vm %q", n.Subnet, subnetState, c.Name) } + return subnetState == state.Running, nil + }) + if errors.Is(err, errWaitTimeout) { + return fmt.Errorf("timed out waiting for subnet %q to be running", n.Subnet) + } + if err != nil { + return err } } return vm.StartVM(db, c.Name, cfg) diff --git a/internal/dispatcher/agent/vpc_commands.go b/internal/dispatcher/agent/vpc_commands.go index df87004..7e73164 100644 --- a/internal/dispatcher/agent/vpc_commands.go +++ b/internal/dispatcher/agent/vpc_commands.go @@ -1,6 +1,7 @@ package dispatcher import ( + "errors" "fmt" "net" "strconv" @@ -129,31 +130,8 @@ func (c DeleteVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error } func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) error { - timeout := time.After(time.Duration(cfg.Dispatcher.TimeoutSeconds) * time.Second) - for { - entries, err := kv.ListByPrefix(db, "subnet/") - if err != nil { - return fmt.Errorf("failed to list subnets: %w", err) - } - pending := false - for key, value := range entries { - if strings.HasSuffix(key, "/vpc") && value == c.Name { - subnetName := strings.Split(key, "/")[1] - s, _ := state.Get(db, "subnet/"+subnetName) - if s == state.Deleting { - pending = true - break - } - } - } - if !pending { - break - } - select { - case <-timeout: - return fmt.Errorf("timed out waiting for subnets of vpc %q to be deleted", c.Name) - case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second): - } + if err := waitSubnetsDeleted(db, c.Name, cfg.Times.VPCStop(), cfg.Times.Poll()); err != nil { + return err } if err := vpc.DeleteVPC(db, c.Name); err != nil { return err @@ -167,3 +145,35 @@ func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) erro } return nil } + +func waitSubnetsDeleted(db *badger.DB, vpcName string, timeout, poll time.Duration) error { + err := waitUntil(timeout, poll, func() (bool, error) { + entries, err := kv.ListByPrefix(db, "subnet/") + if err != nil { + return false, fmt.Errorf("failed to list subnets: %w", err) + } + pending := false + for key, value := range entries { + if !strings.HasSuffix(key, "/vpc") || value != vpcName { + continue + } + subnetName := strings.Split(key, "/")[1] + s, err := state.Get(db, "subnet/"+subnetName) + if err != nil { + continue + } + switch s { + case state.Deleted: + case state.Deleting: + pending = true + default: + return false, fmt.Errorf("subnet %q is %s, vpc %q cannot be deleted", subnetName, s, vpcName) + } + } + return !pending, nil + }) + if errors.Is(err, errWaitTimeout) { + return fmt.Errorf("timed out waiting for subnets of vpc %q to be deleted", vpcName) + } + return err +} diff --git a/internal/dispatcher/agent/wait.go b/internal/dispatcher/agent/wait.go new file mode 100644 index 0000000..2274f33 --- /dev/null +++ b/internal/dispatcher/agent/wait.go @@ -0,0 +1,26 @@ +package dispatcher + +import ( + "errors" + "time" +) + +var errWaitTimeout = errors.New("timed out") + +func waitUntil(timeout, poll time.Duration, done func() (bool, error)) error { + deadline := time.After(timeout) + for { + ok, err := done() + if err != nil { + return err + } + if ok { + return nil + } + select { + case <-deadline: + return errWaitTimeout + case <-time.After(poll): + } + } +} diff --git a/internal/dispatcher/agent/wait_test.go b/internal/dispatcher/agent/wait_test.go new file mode 100644 index 0000000..f3dd7cb --- /dev/null +++ b/internal/dispatcher/agent/wait_test.go @@ -0,0 +1,168 @@ +package dispatcher + +import ( + "errors" + "strings" + "testing" + "time" + + configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/pkg/db/kv" +) + +func TestWaitUntil(t *testing.T) { + calls := 0 + err := waitUntil(time.Second, time.Millisecond, func() (bool, error) { + calls++ + return calls == 3, nil + }) + if err != nil || calls != 3 { + t.Errorf("err %v, %d appels, attendu fin au troisième", err, calls) + } + + if err := waitUntil(30*time.Millisecond, 5*time.Millisecond, func() (bool, error) { return false, nil }); !errors.Is(err, errWaitTimeout) { + t.Errorf("délai dépassé : %v", err) + } + + boom := errors.New("boom") + calls = 0 + err = waitUntil(time.Second, time.Millisecond, func() (bool, error) { + calls++ + return false, boom + }) + if !errors.Is(err, boom) || calls != 1 { + t.Errorf("erreur %v après %d appels, attendu boom au premier", err, calls) + } +} + +func TestDeleteSubnetCommand_Prepare_AcceptsVMsBeingDeleted(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-a/state", "running") + kv.AddInDB(db, "vm/i-a/state", "deleting") + kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") + kv.AddInDB(db, "vm/i-gone/state", "deleted") + kv.AddInDB(db, "vm/i-gone/nic/0/subnet", "sn-a") + if err := (DeleteSubnetCommand{Name: "sn-a"}).Prepare(db, nil); err != nil { + t.Fatalf("VM en deleting : %v", err) + } + if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "deleting" { + t.Errorf("état %q, attendu deleting", s) + } +} + +func TestDeleteSubnetCommand_Prepare_ListsOnlyTheVMsNotBeingDeleted(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-a/state", "running") + kv.AddInDB(db, "vm/i-a/state", "deleting") + kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") + kv.AddInDB(db, "vm/i-b/state", "running") + kv.AddInDB(db, "vm/i-b/nic/0/subnet", "sn-a") + err := DeleteSubnetCommand{Name: "sn-a"}.Prepare(db, nil) + if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-b`) || strings.Contains(err.Error(), "i-a") { + t.Fatalf("erreur %v", err) + } +} + +func TestWaitVMsDeleted_ReturnsOnceTheVMsAreGone(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vm/i-a/state", "deleting") + kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") + kv.AddInDB(db, "vm/i-other/state", "running") + kv.AddInDB(db, "vm/i-other/nic/0/subnet", "sn-b") + go func() { + time.Sleep(30 * time.Millisecond) + kv.DeleteInDB(db, "vm/i-a") + }() + if err := waitVMsDeleted(db, "sn-a", 2*time.Second, 5*time.Millisecond); err != nil { + t.Fatalf("attente : %v", err) + } +} + +func TestWaitVMsDeleted_FailsWhenAVMEndsInError(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vm/i-a/state", "deleting") + kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") + go func() { + time.Sleep(20 * time.Millisecond) + kv.AddInDB(db, "vm/i-a/state", "error") + }() + err := waitVMsDeleted(db, "sn-a", 2*time.Second, 5*time.Millisecond) + if err == nil || !strings.Contains(err.Error(), `vm "i-a" is error, subnet "sn-a" cannot be deleted`) { + t.Fatalf("erreur %v", err) + } +} + +func TestWaitVMsDeleted_TimesOut(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vm/i-a/state", "deleting") + kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") + err := waitVMsDeleted(db, "sn-a", 30*time.Millisecond, 5*time.Millisecond) + if err == nil || err.Error() != `timed out waiting for the vms of subnet "sn-a" to be deleted` { + t.Fatalf("erreur %v", err) + } +} + +func TestWaitSubnetsDeleted_ReturnsOnceTheSubnetsAreGone(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-a/state", "deleting") + kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a") + kv.AddInDB(db, "subnet/sn-b/state", "deleted") + kv.AddInDB(db, "subnet/sn-b/vpc", "vp-a") + kv.AddInDB(db, "subnet/sn-x/state", "running") + kv.AddInDB(db, "subnet/sn-x/vpc", "vp-x") + go func() { + time.Sleep(30 * time.Millisecond) + kv.DeleteInDB(db, "subnet/sn-a") + }() + if err := waitSubnetsDeleted(db, "vp-a", 2*time.Second, 5*time.Millisecond); err != nil { + t.Fatalf("attente : %v", err) + } +} + +func TestWaitSubnetsDeleted_FailsWhenASubnetEndsInError(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-a/state", "deleting") + kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a") + go func() { + time.Sleep(20 * time.Millisecond) + kv.AddInDB(db, "subnet/sn-a/state", "error") + }() + err := waitSubnetsDeleted(db, "vp-a", 2*time.Second, 5*time.Millisecond) + if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is error, vpc "vp-a" cannot be deleted`) { + t.Fatalf("erreur %v", err) + } +} + +func TestWaitSubnetsDeleted_TimesOut(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-a/state", "deleting") + kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a") + err := waitSubnetsDeleted(db, "vp-a", 30*time.Millisecond, 5*time.Millisecond) + if err == nil || err.Error() != `timed out waiting for subnets of vpc "vp-a" to be deleted` { + t.Fatalf("erreur %v", err) + } +} + +func TestDeleteSubnetCommand_Execute_FailsBeforeTouchingTheHostWhenAVMIsInError(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "subnet/sn-a/state", "deleting") + kv.AddInDB(db, "vm/i-a/state", "error") + kv.AddInDB(db, "vm/i-a/nic/0/subnet", "sn-a") + cfg := &configuration.Config{Times: configuration.Times{TimeoutSubnetStop: 1, PollInterval: 1}} + err := DeleteSubnetCommand{Name: "sn-a"}.Execute(db, cfg) + if err == nil || err.Error() != `vm "i-a" is error, subnet "sn-a" cannot be deleted` { + t.Fatalf("erreur %v", err) + } +} + +func TestDeleteVPCCommand_Execute_FailsBeforeTouchingTheHostWhenASubnetIsInError(t *testing.T) { + _, db := newTestDispatcher(t) + kv.AddInDB(db, "vpc/vp-a/state", "deleting") + kv.AddInDB(db, "subnet/sn-a/state", "error") + kv.AddInDB(db, "subnet/sn-a/vpc", "vp-a") + cfg := &configuration.Config{Times: configuration.Times{TimeoutVPCStop: 1, PollInterval: 1}} + err := DeleteVPCCommand{Name: "vp-a"}.Execute(db, cfg) + if err == nil || err.Error() != `subnet "sn-a" is error, vpc "vp-a" cannot be deleted` { + t.Fatalf("erreur %v", err) + } +} diff --git a/internal/vm/delete.go b/internal/vm/delete.go index 06d3658..be87a2a 100644 --- a/internal/vm/delete.go +++ b/internal/vm/delete.go @@ -1,6 +1,7 @@ package vm import ( + "encoding/json" "errors" "fmt" "io/fs" @@ -49,13 +50,7 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { if _, err := os.Stat(socketPath); err == nil { // socket présent : tenter l'arrêt gracieux - if _, err := qmp.Send(socketPath, []string{`{"execute":"system_powerdown"}`}); err == nil { - waitQMPDead(socketPath, - time.Duration(cfg.Dispatcher.TimeoutSeconds)*time.Second, - time.Duration(cfg.Dispatcher.PollSeconds)*time.Second, - ) - } - // connexion QMP échouée : QEMU déjà mort + shutdownQEMU(qmp.Send, socketPath, cfg.Times.VMsStop(), cfg.Times.VMsShutdown(), cfg.Times.Poll()) } // socket absent ou QEMU déjà arrêté : cleanup direct @@ -115,15 +110,31 @@ func removeDHCPFiles(d vmData, name string, backend dhcpbackend.Backend) error { return nil } -func waitQMPDead(socketPath string, timeout, poll time.Duration) { - timer := time.After(timeout) +type qmpSender func(socketPath string, commands []string) ([]json.RawMessage, error) + +const ( + qmpPowerdown = `{"execute":"system_powerdown"}` + qmpQuit = `{"execute":"quit"}` +) + +func shutdownQEMU(send qmpSender, socketPath string, timeout, resend, poll time.Duration) { + if _, err := send(socketPath, []string{qmpPowerdown}); err != nil { + return + } + deadline := time.After(timeout) + again := time.NewTicker(resend) + defer again.Stop() for { select { - case <-timer: - qmp.Send(socketPath, []string{`{"execute":"quit"}`}) + case <-deadline: + send(socketPath, []string{qmpQuit}) return + case <-again.C: + if _, err := send(socketPath, []string{qmpPowerdown}); err != nil { + return + } case <-time.After(poll): - if _, err := qmp.Send(socketPath, nil); err != nil { + if _, err := send(socketPath, nil); err != nil { return } } diff --git a/internal/vm/shutdown_test.go b/internal/vm/shutdown_test.go new file mode 100644 index 0000000..1e5cd6c --- /dev/null +++ b/internal/vm/shutdown_test.go @@ -0,0 +1,102 @@ +package vm + +import ( + "encoding/json" + "errors" + "sync" + "testing" + "time" +) + +type fakeQEMU struct { + mu sync.Mutex + calls []string + dieAfter int + powerdown int + dead bool +} + +func (f *fakeQEMU) send(_ string, commands []string) ([]json.RawMessage, error) { + f.mu.Lock() + defer f.mu.Unlock() + call := "ping" + if len(commands) > 0 { + call = commands[0] + } + f.calls = append(f.calls, call) + if f.dead { + return nil, errors.New("qmp dial: connection refused") + } + switch call { + case qmpPowerdown: + f.powerdown++ + if f.dieAfter > 0 && f.powerdown >= f.dieAfter { + f.dead = true + } + case qmpQuit: + f.dead = true + } + return nil, nil +} + +func (f *fakeQEMU) count(call string) int { + f.mu.Lock() + defer f.mu.Unlock() + n := 0 + for _, c := range f.calls { + if c == call { + n++ + } + } + return n +} + +func TestShutdownQEMU_ResendsPowerdownUntilTheGuestListens(t *testing.T) { + f := &fakeQEMU{dieAfter: 3} + start := time.Now() + shutdownQEMU(f.send, "qmp.sock", 5*time.Second, 50*time.Millisecond, 10*time.Millisecond) + if d := time.Since(start); d > 2*time.Second { + t.Errorf("arrêt en %v : le renvoi aurait dû l'obtenir bien avant le délai", d) + } + if n := f.count(qmpPowerdown); n != 3 { + t.Errorf("%d system_powerdown envoyés, attendu 3 (le troisième est entendu)", n) + } + if n := f.count(qmpQuit); n != 0 { + t.Errorf("quit envoyé alors que l'invité s'est arrêté : %q", f.calls) + } +} + +func TestShutdownQEMU_QuitsAtTheDeadline(t *testing.T) { + f := &fakeQEMU{} + start := time.Now() + shutdownQEMU(f.send, "qmp.sock", 200*time.Millisecond, 60*time.Millisecond, 10*time.Millisecond) + d := time.Since(start) + if d < 200*time.Millisecond || d > 2*time.Second { + t.Errorf("arrêt en %v, attendu au délai de 200ms", d) + } + if n := f.count(qmpPowerdown); n < 3 { + t.Errorf("%d system_powerdown envoyés en 200ms avec un renvoi toutes les 60ms", n) + } + if n := f.count(qmpQuit); n != 1 { + t.Errorf("%d quit envoyés, attendu 1 : %q", n, f.calls) + } +} + +func TestShutdownQEMU_StopsWhenTheGuestShutsDownOnItsOwn(t *testing.T) { + f := &fakeQEMU{dieAfter: 1} + shutdownQEMU(f.send, "qmp.sock", 5*time.Second, time.Second, 10*time.Millisecond) + if n := f.count(qmpPowerdown); n != 1 { + t.Errorf("%d system_powerdown envoyés, attendu 1", n) + } + if n := f.count(qmpQuit); n != 0 { + t.Errorf("quit envoyé : %q", f.calls) + } +} + +func TestShutdownQEMU_NothingMoreWhenQEMUIsAlreadyDead(t *testing.T) { + f := &fakeQEMU{dead: true} + shutdownQEMU(f.send, "qmp.sock", 5*time.Second, time.Second, 10*time.Millisecond) + if len(f.calls) != 1 { + t.Errorf("appels QMP : %q, attendu un seul essai", f.calls) + } +} From f799f8d83ecb04c5e9d63f7864c484374fa54bc6 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 12:42:15 +0100 Subject: [PATCH 12/17] =?UTF-8?q?f-79:=20e2e:=20VM=20et=20subnet=20supprim?= =?UTF-8?q?=C3=A9s=20d'un=20coup,=20wait=5Fstate=20=C3=A0=20480=20s=20#79?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GnomeZworc --- test/e2e/lib/core.sh | 2 +- test/e2e/suite/12-etats.sh | 16 ++++++++++++++-- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/test/e2e/lib/core.sh b/test/e2e/lib/core.sh index fa2a8cf..9002402 100644 --- a/test/e2e/lib/core.sh +++ b/test/e2e/lib/core.sh @@ -56,7 +56,7 @@ api_state () { wait_state () { local path="${1}" want="${2}" i s code="" - for i in $(seq 1 180); do + for i in $(seq 1 240); do s=$(api_state "${path}") [ "${s}" = "${want}" ] && return 0 if [ "${want}" = deleted ] && [ -z "${s}" ]; then diff --git a/test/e2e/suite/12-etats.sh b/test/e2e/suite/12-etats.sh index 5edf9f3..acd71a4 100644 --- a/test/e2e/suite/12-etats.sh +++ b/test/e2e/suite/12-etats.sh @@ -1,6 +1,6 @@ -# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, recréation sous le même nom +# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom # hôtes: hv1 -# tickets: #41, #84 +# tickets: #41, #84, #79 on hv1 <<'NODE' check "VPC vp-t12a" vpc_create vp-t12a 10.12.0.0/16 @@ -41,4 +41,16 @@ check "sn-t12a recréé puis supprimé" wait_state subnets/sn-t12a deleted check "suppression de vp-t12a, sans subnet, 202 (témoin)" expect_code 202 api_code DELETE vpcs/vp-t12a check "vp-t12a supprimé" wait_state vpcs/vp-t12a deleted check "vp-t12a recréé sous le même nom" vpc_create vp-t12a 10.12.0.0/16 + +check "subnet sn-t12q (VNI 1202)" subnet_create sn-t12q vp-t12a 1202 10.12.2.0/24 +check "VM t12-q" vm_create t12-q sn-t12q 10.12.2.10 +sleep 3 +T12Q=$(date +%s) +check "t12-q : suppression 3 s après running, 202" expect_code 202 api_code DELETE vms/t12-q +check "sn-t12q : suppression envoyée aussitôt, acceptée malgré t12-q en deleting, 202" expect_code 202 api_code DELETE subnets/sn-t12q +info "sn-t12q juste après sa suppression : $(api_state subnets/sn-t12q), t12-q : $(api_state vms/t12-q)" +check "t12-q supprimée" wait_state vms/t12-q deleted +check "sn-t12q supprimé après t12-q" wait_state subnets/sn-t12q deleted +info "t12-q puis sn-t12q supprimés en $(( $(date +%s) - T12Q )) s" +check "t12-q : arrêtée bien avant times.timeout_vms_stop (300 s), par un system_powerdown renvoyé si le premier est perdu" test "$(( $(date +%s) - T12Q ))" -lt 200 NODE From 630cb990480d936da6ce53489cb8e04242f4705b Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 12:42:20 +0100 Subject: [PATCH 13/17] f-79: doc: section times, suppressions en cascade, notes 0.3.0 #79 Signed-off-by: GnomeZworc --- docs/architecture/contraintes.rst | 3 +- docs/concepts/cycle-de-vie.rst | 5 ++- docs/demarrage/premier-vpc.rst | 2 +- docs/developpement/lab.rst | 6 +-- docs/exploitation/api-agent/asynchronisme.rst | 16 ++++--- docs/exploitation/configuration.rst | 44 +++++++++++++++---- release_notes/0.3.0.md | 25 +++++++++++ 7 files changed, 81 insertions(+), 20 deletions(-) diff --git a/docs/architecture/contraintes.rst b/docs/architecture/contraintes.rst index dc1ca06..636796b 100644 --- a/docs/architecture/contraintes.rst +++ b/docs/architecture/contraintes.rst @@ -50,7 +50,8 @@ QEMU et VM exécuté par le processus appelant et hérite du netns posé par ``netns.Call``. Une unit transitoire, forkée par PID 1, démarrerait dans le netns racine et ne verrait pas le tap. * L'arrêt d'une VM ne touche **jamais** aux fichiers disque. En revanche, un ``quit`` brutal est - envoyé à l'expiration de ``dispatcher.timeout_seconds``. + envoyé à l'expiration de ``times.timeout_vms_stop``. ``system_powerdown`` est renvoyé toutes les + ``times.next_vms_shutdown`` : un appui ACPI arrivé avant que l'invité sache le traiter est perdu. Arrêt de l'agent ---------------- diff --git a/docs/concepts/cycle-de-vie.rst b/docs/concepts/cycle-de-vie.rst index bf41484..adcc57b 100644 --- a/docs/concepts/cycle-de-vie.rst +++ b/docs/concepts/cycle-de-vie.rst @@ -40,7 +40,10 @@ Suppression Elle n'est autorisée que depuis ``running`` ou ``error`` — sinon **409**. Depuis ``error``, elle est **best-effort** : les ressources système peuvent n'avoir été créées que partiellement. -Un VPC ne peut être supprimé qu'une fois tous ses subnets supprimés. +Un VPC ne peut être supprimé qu'une fois tous ses subnets supprimés ou en ``deleting``, un subnet +qu'une fois toutes ses VM supprimées ou en ``deleting``. Les enfants encore en ``deleting`` sont +attendus (``times.timeout_vpc_stop``, ``times.timeout_subnet_stop``) ; si l'un d'eux passe en +``error``, la suppression du parent échoue, et le parent passe en ``error`` à son tour. Pas de rollback --------------- diff --git a/docs/demarrage/premier-vpc.rst b/docs/demarrage/premier-vpc.rst index 534dd55..b55693f 100644 --- a/docs/demarrage/premier-vpc.rst +++ b/docs/demarrage/premier-vpc.rst @@ -48,7 +48,7 @@ La réponse est un **202** : la création est acceptée, pas terminée. Un subnet peut être demandé dès maintenant : il est accepté tant que le VPC est en ``creating`` ou ``running``, et sa création attend que le VPC soit ``running``, dans la limite de -``dispatcher.timeout_seconds``. Il n'est refusé en **422** que si le VPC est absent, en ``error`` +``times.timeout_subnet_start``. Il n'est refusé en **422** que si le VPC est absent, en ``error`` ou en ``deleting``. Le modèle d'attente est décrit dans :doc:`/exploitation/api-agent/asynchronisme`. 2. Le subnet diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index 7574ab2..dea674e 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -298,9 +298,9 @@ Générée par ``test/e2e/run.sh --matrice`` à partir des en-têtes ; à régé - hv1 - #41, #57, #33, #62, #74, #81 * - ``12-etats`` - - machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, recréation sous le même nom + - machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom - hv1 - - #41, #84 + - #41, #84, #79 * - ``21-dhcp-two`` - DHCP par le serveur intégré (backend two) — bail, server-id, renouvellement, option 121, un serveur par subnet, démarrages simultanés - hv1 @@ -416,7 +416,7 @@ tests ont été corrigées sur le serveur et les tests concernés rejoués. Il r établie**. ``72-perte-switch`` n'exige donc plus que le plus prioritaire redevienne maître : il vérifie qu'il n'y a qu'un maître, note lequel, et mesure le plus long silence après le retour ; * une suppression de VM peut durer 300 s quand l'invité ignore l'arrêt ACPI (#79) : ``wait_state`` - attend jusqu'à 360 s. + attend jusqu'à 480 s, au-delà du ``times.timeout_vpc_stop`` par défaut (420 s). Hypothèses vérifiées en lab, à garder en tête en écrivant un test : diff --git a/docs/exploitation/api-agent/asynchronisme.rst b/docs/exploitation/api-agent/asynchronisme.rst index 7c4875b..926ae54 100644 --- a/docs/exploitation/api-agent/asynchronisme.rst +++ b/docs/exploitation/api-agent/asynchronisme.rst @@ -44,14 +44,18 @@ un état stable. Trois règles pour un appelant robuste : -* **Toujours borner l'attente.** Côté agent, ``dispatcher.timeout_seconds`` (300 s par défaut) - borne les opérations qui attendent une transition ; l'appelant doit avoir sa propre borne. +* **Toujours borner l'attente.** Côté agent, la section ``times`` de la configuration borne les + opérations qui attendent une transition ; l'appelant doit avoir sa propre borne. * **Traiter ``error`` comme terminal, pas comme un échec transitoire.** Un ``Execute`` en échec ne se rejoue pas tout seul. * **Savoir ce qui s'enchaîne.** Créer un subnet dont le VPC est encore en ``creating``, ou démarrer une VM sur un subnet en ``creating``, est accepté : l'``Execute`` attend que le parent - passe ``running``, dans la limite de ``dispatcher.timeout_seconds`` ; au-delà, la ressource passe - en ``error``. Le refus en 422 ne vaut que pour un parent absent, en ``error`` ou en ``deleting``. + passe ``running``, dans la limite de ``times.timeout_subnet_start`` ou ``times.timeout_vms_start`` ; + au-delà, la ressource passe en ``error``. Le refus en 422 ne vaut que pour un parent absent, en + ``error`` ou en ``deleting``. À la suppression, c'est l'inverse : une VM puis son subnet, ou un + subnet puis son VPC, peuvent être supprimés d'un coup ; le parent attend que ses enfants en + ``deleting`` soient supprimés (``times.timeout_subnet_stop``, ``times.timeout_vpc_stop``), et passe + en ``error`` si l'un d'eux échoue. Codes de retour --------------- @@ -78,8 +82,8 @@ Codes de retour * - ``409`` - conflit d'existence ou d'état : ressource déjà créée, ou suppression depuis un état qui ne l'autorise pas ; pour un VPC, subnets encore présents, ``l3vni`` déjà utilisée par un - autre VPC, ou ``l3vni`` demandée sans section ``bgp`` ; pour un subnet, VM non supprimées - qui l'utilisent encore + autre VPC, ou ``l3vni`` demandée sans section ``bgp`` ; pour un subnet, VM qui l'utilisent + encore, ni supprimées ni en ``deleting`` * - ``422`` - dépendance absente ou inutilisable : VPC parent d'un subnet, subnet d'une VM, absent, en ``error`` ou en ``deleting`` ; ``mode`` de subnet inconnu ; CIDR ``vxlan`` invalide ou plus diff --git a/docs/exploitation/configuration.rst b/docs/exploitation/configuration.rst index 30cb353..fcbdc61 100644 --- a/docs/exploitation/configuration.rst +++ b/docs/exploitation/configuration.rst @@ -72,21 +72,49 @@ Exécution des commandes count: 4 buffer_size: 100 - dispatcher: - timeout_seconds: 300 - poll_seconds: 2 + times: + timeout_vms_stop: 300 + next_vms_shutdown: 30 + timeout_subnet_stop: 360 + timeout_vpc_stop: 420 + timeout_subnet_start: 300 + timeout_vms_start: 300 + poll_interval: 2 ``worker.count`` est le nombre de goroutines qui exécutent les commandes ; ``buffer_size`` le nombre de commandes en attente au-delà duquel ``Dispatch`` bloque. -``dispatcher.timeout_seconds`` borne les opérations qui attendent une transition d'état, dont -l'extinction d'une VM. +La section ``times`` règle, en secondes, les attentes des commandes asynchrones : + +``timeout_vms_stop`` + arrêt propre d'une VM : au-delà, QEMU reçoit un ``quit`` QMP. +``next_vms_shutdown`` + intervalle entre deux ``system_powerdown`` pendant cet arrêt. Un invité qui n'écoutait pas + encore l'ACPI au premier appui (firmware, chargeur de démarrage) s'éteint au suivant. +``timeout_subnet_stop`` + suppression d'un subnet : attente de ses VM encore en ``deleting``. +``timeout_vpc_stop`` + suppression d'un VPC : attente de ses subnets encore en ``deleting``. +``timeout_subnet_start`` + création d'un subnet : attente de son VPC ``running``. +``timeout_vms_start`` + création d'une VM : attente des subnets de ses interfaces ``running``. +``poll_interval`` + pas de toutes ces attentes. + +Chaque valeur doit être strictement positive, et ``next_vms_shutdown`` inférieur à +``timeout_vms_stop`` ; sinon l'agent refuse de démarrer. Les attentes s'enchaînent — une VM, +puis son subnet, puis le VPC : garder ``timeout_vms_stop`` < ``timeout_subnet_stop`` < +``timeout_vpc_stop`` pour qu'une suppression en cascade envoyée d'un coup aboutisse. + +L'ancienne section ``dispatcher`` (``timeout_seconds``, ``poll_seconds``) n'est plus lue : restée +dans un fichier, elle est ignorée. .. warning:: - À l'expiration de ce délai, une VM qui ne s'est pas éteinte reçoit un ``quit`` QMP — un arrêt - **brutal**. Pour des charges dont l'extinction est lente (bases de données, construction - d'images), une valeur confortable évite un système de fichiers invité incohérent. + À l'expiration de ``timeout_vms_stop``, une VM qui ne s'est pas éteinte reçoit un ``quit`` + QMP — un arrêt **brutal**. Pour des charges dont l'extinction est lente (bases de données, + construction d'images), une valeur confortable évite un système de fichiers invité incohérent. Correspondance des interfaces ----------------------------- diff --git a/release_notes/0.3.0.md b/release_notes/0.3.0.md index ad63707..8038a58 100644 --- a/release_notes/0.3.0.md +++ b/release_notes/0.3.0.md @@ -1,5 +1,19 @@ # Gabriel +## Fonctionnalités + +**Délais dédiés : section `times` (#79)** + +- Nouvelle section `times` de la configuration, en secondes : `timeout_vms_stop` (300), + `next_vms_shutdown` (30), `timeout_subnet_stop` (360), `timeout_vpc_stop` (420), + `timeout_subnet_start` (300), `timeout_vms_start` (300), `poll_interval` (2). Elle remplace + `dispatcher.timeout_seconds` et `dispatcher.poll_seconds`, qui servaient à des attentes de + nature différente. Une valeur nulle ou négative, ou `next_vms_shutdown` au moins égal à + `timeout_vms_stop`, fait échouer le démarrage +- **Une VM et son subnet se suppriment d'un coup** : la suppression d'un subnet est acceptée + quand ses VM sont en `deleting`, et attend leur suppression jusqu'à `timeout_subnet_stop`. Le + 409 reste pour une VM ni supprimée ni en `deleting` + ## Correctifs - **Chaque VRF de VPC porte une route `unreachable default` (#81).** Une recherche qui échouait @@ -16,6 +30,13 @@ (disque absent par exemple), il pouvait laisser `.sock` dans `serial_dir`, `monitor_dir` ou `qmp_dir`, que la suppression de la VM ne retirait pas. Les trois sont désormais supprimés une fois QEMU arrêté ; un fichier absent n'est pas une erreur +- **`system_powerdown` est renvoyé toutes les `next_vms_shutdown` secondes (#79)** pendant + l'arrêt d'une VM, jusqu'à `timeout_vms_stop`. Un seul appui était envoyé : arrivé avant que + l'invité sache le traiter (firmware, chargeur de démarrage), il était perdu, et la suppression + durait les 300 s du délai avant un `quit` brutal (mesuré en lab) +- **La suppression d'un VPC échoue si l'un de ses subnets échoue (#79).** Elle attendait qu'aucun + subnet ne soit plus en `deleting`, puis supprimait le VPC même si un subnet était passé en + `error`. Il en va de même pour un subnet dont une VM attendue passe en `error` ## Mise à jour depuis la 0.2.0 @@ -27,3 +48,7 @@ la fuite vers l'underlay décrite plus haut reste possible. Pour la fermer sans recréer le VPC, la poser à la main sur chaque hyperviseur, la table étant le `l3vni` du VPC : `ip route replace unreachable default metric 4278198272 table ` +- **La section `dispatcher` n'est plus lue** : restée dans `/etc/two/agent.yml`, elle est ignorée, + et les valeurs par défaut de `times` s'appliquent. Une valeur personnalisée de + `dispatcher.timeout_seconds` est à reporter dans `times.timeout_vms_stop` (et dans les délais + qui en dépendent) From bc5ca2b9a8413a543dd9f8cc8a0362545ff974b5 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 13:18:24 +0100 Subject: [PATCH 14/17] f-87: e2e: bordures bd1 et bd2 dans evpn-3hv, VNI 66001, gateway anycast #87 Signed-off-by: GnomeZworc --- docs/developpement/lab.rst | 12 ++++++++++++ test/e2e/topologies/evpn-3hv.yml | 6 ++++++ test/e2e/topologies/frr/bd1.conf | 19 +++++++++++++++++++ test/e2e/topologies/frr/bd2.conf | 19 +++++++++++++++++++ test/e2e/topologies/provision/border.sh | 18 ++++++++++++++++++ 5 files changed, 74 insertions(+) create mode 100644 test/e2e/topologies/frr/bd1.conf create mode 100644 test/e2e/topologies/frr/bd2.conf create mode 100755 test/e2e/topologies/provision/border.sh diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index dea674e..f5feaa7 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -127,6 +127,18 @@ un subnet créé avec ``mode: bridge`` et ``iface_type: lan`` rattache son veth subnets ``vxlan`` (``iface_type: vms``, clé absente) restent sur ``default_interface`` : le VTEP ne change pas. Le bridge n'est créé qu'au premier démarrage, comme le reste du provisionnement. +**Bordures (``evpn-3hv``, #87).** ``bd1`` et ``bd2`` (``192.168.14.21`` et ``.22``) jouent les +routeurs de bordure du segment public. Ce sont des nœuds ``host`` sans agent : leur provision +(``test/e2e/topologies/provision/border.sh``) crée ``br-public``, y accroche ``vxlan-66001`` +(VNI 66001, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway +anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:01:01:d1`` (la MAC anycast +de two pour le VNI 66001), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface +``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur : iBGP AS 64600 vers les +deux route reflectors, ``advertise-all-vni``. Les adresses publiques du lab sont prises dans +``240.0.0.0/4``, réservée (RFC 1112, registre RFC 6890) et jamais routée sur Internet. Les bordures +sont déclarées après les hyperviseurs : les adresses et les taps de l'underlay ne changent pas, +ceux du segment ``lan`` sont renumérotés. + **Tester l'arbre courant plutôt que la release.** ``test/e2e/build.sh`` compile ``agent``, ``dhcp`` et ``metadata`` pour linux/amd64 dans ``test/e2e/topologies/bin/`` (ignoré par git), que les hyperviseurs reçoivent par ``files: {bin: bin}``. Après ``deploy.sh``, diff --git a/test/e2e/topologies/evpn-3hv.yml b/test/e2e/topologies/evpn-3hv.yml index 58c38d5..a32ac1c 100644 --- a/test/e2e/topologies/evpn-3hv.yml +++ b/test/e2e/topologies/evpn-3hv.yml @@ -48,3 +48,9 @@ nodes: addresses: { underlay: 192.168.14.13 }, frr: frr/hv3.conf, provision: provision/hypervisor.sh, post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin }, services: [agent.service] } + bd1: + { role: host, image: debian12, cpus: 1, memory: 1024, segments: [underlay], + addresses: { underlay: 192.168.14.21 }, frr: frr/bd1.conf, provision: provision/border.sh } + bd2: + { role: host, image: debian12, cpus: 1, memory: 1024, segments: [underlay], + addresses: { underlay: 192.168.14.22 }, frr: frr/bd2.conf, provision: provision/border.sh } diff --git a/test/e2e/topologies/frr/bd1.conf b/test/e2e/topologies/frr/bd1.conf new file mode 100644 index 0000000..0a3d79c --- /dev/null +++ b/test/e2e/topologies/frr/bd1.conf @@ -0,0 +1,19 @@ +frr defaults traditional +hostname bd1 +log syslog informational +! +router bgp 64600 + bgp router-id 192.168.14.21 + 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 +! diff --git a/test/e2e/topologies/frr/bd2.conf b/test/e2e/topologies/frr/bd2.conf new file mode 100644 index 0000000..e1ce95a --- /dev/null +++ b/test/e2e/topologies/frr/bd2.conf @@ -0,0 +1,19 @@ +frr defaults traditional +hostname bd2 +log syslog informational +! +router bgp 64600 + bgp router-id 192.168.14.22 + 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 +! diff --git a/test/e2e/topologies/provision/border.sh b/test/e2e/topologies/provision/border.sh new file mode 100755 index 0000000..524bca2 --- /dev/null +++ b/test/e2e/topologies/provision/border.sh @@ -0,0 +1,18 @@ +#!/bin/sh +set -eu +VNI=66001 +GATEWAY=240.0.0.1/24 +GATEWAY_MAC=02:01:00:01:01:d1 +DESTINATION=240.255.0.1/32 +VTEP=$(ip -4 -o addr show dev "${LAB_UPLINK}" scope global | awk 'NR == 1 {sub("/.*", "", $4); print $4}') +[ -n "${VTEP}" ] || { echo "border: no IPv4 on ${LAB_UPLINK}" >&2; exit 1; } +ip link add br-public type bridge +ip link set br-public address "${GATEWAY_MAC}" +ip link add "vxlan-${VNI}" type vxlan id "${VNI}" local "${VTEP}" dstport 4789 nolearning +ip link set "vxlan-${VNI}" mtu 1500 master br-public +ip link set "vxlan-${VNI}" up +ip link set br-public up +ip addr add "${GATEWAY}" dev br-public +ip link add internet type dummy +ip addr add "${DESTINATION}" dev internet +ip link set internet up From e204de20af4396c1d98823cfc9d8d647f52e27fb Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 19:19:45 +0100 Subject: [PATCH 15/17] f-87: e2e: advertise-default-gw sur les bordures, gateway en type 2 #87 Signed-off-by: GnomeZworc --- docs/developpement/lab.rst | 15 ++++++++++----- test/e2e/topologies/frr/bd1.conf | 1 + test/e2e/topologies/frr/bd2.conf | 1 + 3 files changed, 12 insertions(+), 5 deletions(-) diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index f5feaa7..b609fe3 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -133,11 +133,16 @@ routeurs de bordure du segment public. Ce sont des nœuds ``host`` sans agent : (VNI 66001, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:01:01:d1`` (la MAC anycast de two pour le VNI 66001), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface -``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur : iBGP AS 64600 vers les -deux route reflectors, ``advertise-all-vni``. Les adresses publiques du lab sont prises dans -``240.0.0.0/4``, réservée (RFC 1112, registre RFC 6890) et jamais routée sur Internet. Les bordures -sont déclarées après les hyperviseurs : les adresses et les taps de l'underlay ne changent pas, -ceux du segment ``lan`` sont renumérotés. +``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur — iBGP AS 64600 vers les +deux route reflectors, ``advertise-all-vni`` — plus ``advertise-default-gw`` : la MAC et l'IP +de la gateway sont annoncées en type 2 avec la communauté *Default Gateway* (RFC 7432, §7.8 et +§10.1). Sans elle, la MAC propre du bridge n'est pas annoncée, les hyperviseurs inondent le +trafic vers tous les VTEP et les deux bordures répondent ; avec elle, chaque hyperviseur installe +la MAC vers une seule bordure et bascule sur l'autre quand elle disparaît (mesuré le 2026-10-25, +#87). Les adresses publiques du lab sont prises dans ``240.0.0.0/4``, réservée (RFC 1112, +registre RFC 6890) et jamais routée sur Internet. Les bordures sont déclarées après les +hyperviseurs : les adresses et les taps de l'underlay ne changent pas, ceux du segment ``lan`` +sont renumérotés. **Tester l'arbre courant plutôt que la release.** ``test/e2e/build.sh`` compile ``agent``, ``dhcp`` et ``metadata`` pour linux/amd64 dans ``test/e2e/topologies/bin/`` (ignoré par git), diff --git a/test/e2e/topologies/frr/bd1.conf b/test/e2e/topologies/frr/bd1.conf index 0a3d79c..71143c2 100644 --- a/test/e2e/topologies/frr/bd1.conf +++ b/test/e2e/topologies/frr/bd1.conf @@ -14,6 +14,7 @@ router bgp 64600 address-family l2vpn evpn neighbor fabric activate advertise-all-vni + advertise-default-gw exit-address-family exit ! diff --git a/test/e2e/topologies/frr/bd2.conf b/test/e2e/topologies/frr/bd2.conf index e1ce95a..71ccb61 100644 --- a/test/e2e/topologies/frr/bd2.conf +++ b/test/e2e/topologies/frr/bd2.conf @@ -14,6 +14,7 @@ router bgp 64600 address-family l2vpn evpn neighbor fabric activate advertise-all-vni + advertise-default-gw exit-address-family exit ! From e8c45c74b34784dd7eef6c2360e69faa72195b3d Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 23:31:25 +0100 Subject: [PATCH 16/17] f-87: deploy: vxlan-public sur br-public, --public_vni (1), lab au VNI 1 #87 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit bootstrap_kvm.sh crée vxlan-public (VTEP = IPv4 du bridge principal, nolearning) esclave du bridge public, recréé si le VNI ou le VTEP change. Lab : bordures au VNI 1 (MAC 02:01:00:00:00:01) ; build.sh copie bootstrap_kvm.sh, que hypervisor.sh appelle après la release 0.2.0. Signed-off-by: GnomeZworc --- .gitignore | 2 + docs/developpement/lab.rst | 8 +-- scripts/bootstrap_kvm.sh | 55 +++++++++++++++++++-- scripts/deploy.sh | 5 +- test/e2e/build.sh | 21 +++++--- test/e2e/topologies/evpn-2hv.yml | 4 +- test/e2e/topologies/evpn-3hv.yml | 6 +-- test/e2e/topologies/provision/border.sh | 10 ++-- test/e2e/topologies/provision/hypervisor.sh | 6 +++ test/e2e/topologies/scripts/.gitkeep | 0 10 files changed, 90 insertions(+), 27 deletions(-) create mode 100644 test/e2e/topologies/scripts/.gitkeep diff --git a/.gitignore b/.gitignore index 3f0d6a4..8ed7508 100644 --- a/.gitignore +++ b/.gitignore @@ -37,3 +37,5 @@ docs/_build/ # Binaires compilés en local pour le lab (test/e2e/build.sh) test/e2e/topologies/bin/* !test/e2e/topologies/bin/.gitkeep +test/e2e/topologies/scripts/* +!test/e2e/topologies/scripts/.gitkeep diff --git a/docs/developpement/lab.rst b/docs/developpement/lab.rst index b609fe3..2b195db 100644 --- a/docs/developpement/lab.rst +++ b/docs/developpement/lab.rst @@ -129,10 +129,10 @@ ne change pas. Le bridge n'est créé qu'au premier démarrage, comme le reste d **Bordures (``evpn-3hv``, #87).** ``bd1`` et ``bd2`` (``192.168.14.21`` et ``.22``) jouent les routeurs de bordure du segment public. Ce sont des nœuds ``host`` sans agent : leur provision -(``test/e2e/topologies/provision/border.sh``) crée ``br-public``, y accroche ``vxlan-66001`` -(VNI 66001, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway -anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:01:01:d1`` (la MAC anycast -de two pour le VNI 66001), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface +(``test/e2e/topologies/provision/border.sh``) crée ``br-public``, y accroche ``vxlan-public`` +(VNI 1, VTEP = adresse de l'underlay, ``nolearning``), et pose sur le bridge la **gateway +anycast** ``240.0.0.1/24`` avec la même MAC sur les deux, ``02:01:00:00:00:01`` (la MAC anycast +de two pour le VNI 1), ainsi qu'une destination de test ``240.255.0.1/32`` sur une interface ``dummy`` ``internet``. Leur ``frr.conf`` est celui d'un hyperviseur — iBGP AS 64600 vers les deux route reflectors, ``advertise-all-vni`` — plus ``advertise-default-gw`` : la MAC et l'IP de la gateway sont annoncées en type 2 avec la communauté *Default Gateway* (RFC 7432, §7.8 et diff --git a/scripts/bootstrap_kvm.sh b/scripts/bootstrap_kvm.sh index 220a511..341ebba 100755 --- a/scripts/bootstrap_kvm.sh +++ b/scripts/bootstrap_kvm.sh @@ -77,8 +77,8 @@ kvm_network () { info "réseau" - # Bridge public : créé à vide, réservé pour un usage futur. Aucune adresse, - # aucun esclave, pas référencé dans la config agent. + # Bridge public : sans adresse. Il reçoit le VXLAN du segment public + # (kvm_public_segment) et les veth vp--e des VPC (interfaces.internet). kvm_ensure_bridge "${DRY_RUN}" "${PUBLIC_BRIDGE}" MASTER="" @@ -153,6 +153,49 @@ EOF info " rollback désarmé" } +# VXLAN du segment public, partagé avec les bordures, esclave du bridge public. +# VTEP = IPv4 du bridge principal, comme les VXLAN de l'agent ; sans +# apprentissage, les MAC distantes viennent d'EVPN. Recréé si le VNI ou le VTEP +# a changé. +kvm_public_segment () { + local DRY_RUN="${1}" + local WITH_NETWORK="${2}" + local BRIDGE="${3}" + local PUBLIC_BRIDGE="${4}" + local PUBLIC_VNI="${5}" + local NAME="vxlan-public" + local VTEP CURRENT="" + + [[ ${WITH_NETWORK} -eq ${FLAGS_TRUE} ]] || return 0 + [[ "${PUBLIC_VNI}" =~ ^[0-9]+$ ]] && (( PUBLIC_VNI >= 1 && PUBLIC_VNI <= 16777215 )) \ + || die "VNI du segment public invalide : ${PUBLIC_VNI} (1-16777215)" + + info "segment public : ${NAME}, VNI ${PUBLIC_VNI}, sur ${PUBLIC_BRIDGE}" + + if [[ ${DRY_RUN} -eq ${FLAGS_TRUE} ]] + then + VTEP="" + else + VTEP=$(ip -j addr show dev "${BRIDGE}" | jq -r '[.[0].addr_info[] | select(.family=="inet" and .scope=="global")][0].local // ""') + [[ -n "${VTEP}" ]] || die "aucune adresse IPv4 globale sur ${BRIDGE} pour le VTEP du segment public" + if ip link show dev "${NAME}" >/dev/null 2>&1 + then + CURRENT=$(ip -j -d link show dev "${NAME}" | jq -r '.[0].linkinfo.info_data | "\(.id) \(.local)"') + fi + fi + + if [[ -n "${CURRENT}" && "${CURRENT}" != "${PUBLIC_VNI} ${VTEP}" ]] + then + info " ${NAME} porte ${CURRENT} (VNI VTEP) : recréé" + run "${DRY_RUN}" "ip link del dev '${NAME}'" + CURRENT="" + fi + [[ -n "${CURRENT}" ]] \ + || run "${DRY_RUN}" "ip link add '${NAME}' type vxlan id ${PUBLIC_VNI} local '${VTEP}' dstport 4789 nolearning" + run "${DRY_RUN}" "ip link set dev '${NAME}' mtu 1500 master '${PUBLIC_BRIDGE}'" + run "${DRY_RUN}" "ip link set up dev '${NAME}'" +} + # Point d'entrée appelé par deploy.sh --bootstrap. bootstrap_host () { local DRY_RUN="${1}" @@ -162,8 +205,10 @@ bootstrap_host () { local BRIDGE="${5}" local PUBLIC_BRIDGE="${6}" local ROLLBACK_DELAY="${7}" + local PUBLIC_VNI="${8:-1}" - kvm_packages "${DRY_RUN}" "${WITH_PACKAGES}" - kvm_kernel "${DRY_RUN}" - kvm_network "${DRY_RUN}" "${WITH_NETWORK}" "${UPLINK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${ROLLBACK_DELAY}" + kvm_packages "${DRY_RUN}" "${WITH_PACKAGES}" + kvm_kernel "${DRY_RUN}" + kvm_network "${DRY_RUN}" "${WITH_NETWORK}" "${UPLINK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${ROLLBACK_DELAY}" + kvm_public_segment "${DRY_RUN}" "${WITH_NETWORK}" "${BRIDGE}" "${PUBLIC_BRIDGE}" "${PUBLIC_VNI}" } diff --git a/scripts/deploy.sh b/scripts/deploy.sh index b654197..c431697 100755 --- a/scripts/deploy.sh +++ b/scripts/deploy.sh @@ -159,7 +159,7 @@ run_bootstrap () { || die "bootstrap_host() introuvable — ni ${SCRIPTS_DIR}/${NAME} ni ${BOOTSTRAP_URL} n'ont pu être chargés" bootstrap_host "${DRY_RUN}" "${FLAGS_packages}" "${FLAGS_network}" \ - "${FLAGS_uplink}" "${FLAGS_bridge}" "${FLAGS_pub_bridge}" "${FLAGS_rollback}" + "${FLAGS_uplink}" "${FLAGS_bridge}" "${FLAGS_pub_bridge}" "${FLAGS_rollback}" "${FLAGS_public_vni}" } resolve_tag () { @@ -335,7 +335,8 @@ main () { DEFINE_boolean 'network' true 'Configure bridges during --bootstrap' 'n' DEFINE_string 'uplink' 'eno1' 'Physical uplink interface' 'u' DEFINE_string 'bridge' 'br-000000' 'Main bridge, uplink is enslaved to it' 'B' - DEFINE_string 'pub_bridge' 'br-public' 'Reserved empty bridge' 'P' + DEFINE_string 'pub_bridge' 'br-public' 'Public bridge, carries vxlan-public' 'P' + DEFINE_integer 'public_vni' 1 'VNI of the public segment (vxlan-public)' 'N' DEFINE_integer 'rollback' 120 'Rollback reboot delay in seconds' 'R' DEFINE_boolean 'verify' true 'Check assets against SHA256SUMS' 'V' diff --git a/test/e2e/build.sh b/test/e2e/build.sh index 786f211..992c7ae 100755 --- a/test/e2e/build.sh +++ b/test/e2e/build.sh @@ -3,33 +3,42 @@ E2E_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" REPO_DIR="$(cd "${E2E_DIR}/../.." && pwd)" BIN_DIR="${BIN_DIR:-${E2E_DIR}/topologies/bin}" +SCRIPTS_DIR="${SCRIPTS_DIR:-${E2E_DIR}/topologies/scripts}" BINARIES="agent dhcp metadata" +SCRIPTS="bootstrap_kvm.sh" usage () { cat >&2 <&2 (cd "${REPO_DIR}" && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o "${BIN_DIR}/${binary}" "./cmd/${binary}") || return 1 done + for script in ${SCRIPTS}; do + echo "== ${script}" >&2 + cp "${REPO_DIR}/scripts/${script}" "${SCRIPTS_DIR}/${script}" || return 1 + done (cd "${BIN_DIR}" && sha256sum ${BINARIES} 2>/dev/null || shasum -a 256 ${BINARIES}) } diff --git a/test/e2e/topologies/evpn-2hv.yml b/test/e2e/topologies/evpn-2hv.yml index 8041ab3..c89f668 100644 --- a/test/e2e/topologies/evpn-2hv.yml +++ b/test/e2e/topologies/evpn-2hv.yml @@ -35,11 +35,11 @@ nodes: { role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay, lan], addresses: { underlay: 192.168.14.11, lan: 10.33.0.11 }, frr: frr/hv1.conf, provision: provision/hypervisor.sh, - post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin }, + post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin, scripts: scripts }, services: [agent.service] } hv2: { role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay, lan], addresses: { underlay: 192.168.14.12, lan: 10.33.0.12 }, frr: frr/hv2.conf, provision: provision/hypervisor.sh, - post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin }, + post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin, scripts: scripts }, services: [agent.service] } diff --git a/test/e2e/topologies/evpn-3hv.yml b/test/e2e/topologies/evpn-3hv.yml index a32ac1c..d3b5d2c 100644 --- a/test/e2e/topologies/evpn-3hv.yml +++ b/test/e2e/topologies/evpn-3hv.yml @@ -35,18 +35,18 @@ nodes: { role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay, lan], addresses: { underlay: 192.168.14.11, lan: 10.33.0.11 }, frr: frr/hv1.conf, provision: provision/hypervisor.sh, - post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin }, + post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/two.yml, bin: bin, scripts: scripts }, services: [agent.service] } hv2: { role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay, lan], addresses: { underlay: 192.168.14.12, lan: 10.33.0.12 }, frr: frr/hv2.conf, provision: provision/hypervisor.sh, - post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin }, + post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin, scripts: scripts }, services: [agent.service] } hv3: { role: host, image: debian12, cpus: 4, memory: 16384, segments: [underlay], addresses: { underlay: 192.168.14.13 }, frr: frr/hv3.conf, provision: provision/hypervisor.sh, - post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin }, + post_provision: provision/hypervisor-post.sh, files: { agent.yml: agent/dnsmasq.yml, bin: bin, scripts: scripts }, services: [agent.service] } bd1: { role: host, image: debian12, cpus: 1, memory: 1024, segments: [underlay], diff --git a/test/e2e/topologies/provision/border.sh b/test/e2e/topologies/provision/border.sh index 524bca2..c72c9b0 100755 --- a/test/e2e/topologies/provision/border.sh +++ b/test/e2e/topologies/provision/border.sh @@ -1,16 +1,16 @@ #!/bin/sh set -eu -VNI=66001 +VNI=1 GATEWAY=240.0.0.1/24 -GATEWAY_MAC=02:01:00:01:01:d1 +GATEWAY_MAC=02:01:00:00:00:01 DESTINATION=240.255.0.1/32 VTEP=$(ip -4 -o addr show dev "${LAB_UPLINK}" scope global | awk 'NR == 1 {sub("/.*", "", $4); print $4}') [ -n "${VTEP}" ] || { echo "border: no IPv4 on ${LAB_UPLINK}" >&2; exit 1; } ip link add br-public type bridge ip link set br-public address "${GATEWAY_MAC}" -ip link add "vxlan-${VNI}" type vxlan id "${VNI}" local "${VTEP}" dstport 4789 nolearning -ip link set "vxlan-${VNI}" mtu 1500 master br-public -ip link set "vxlan-${VNI}" up +ip link add vxlan-public type vxlan id "${VNI}" local "${VTEP}" dstport 4789 nolearning +ip link set vxlan-public mtu 1500 master br-public +ip link set vxlan-public up ip link set br-public up ip addr add "${GATEWAY}" dev br-public ip link add internet type dummy diff --git a/test/e2e/topologies/provision/hypervisor.sh b/test/e2e/topologies/provision/hypervisor.sh index 3257dc1..4d4b52d 100755 --- a/test/e2e/topologies/provision/hypervisor.sh +++ b/test/e2e/topologies/provision/hypervisor.sh @@ -1,6 +1,7 @@ #!/bin/sh set -eu RELEASE=0.2.0 +PUBLIC_VNI=1 GIT_SERVER=https://git.g3e.fr/ REPO=syonad/two n=0 @@ -28,6 +29,11 @@ for script in deploy.sh bootstrap_kvm.sh; do done chmod 0755 deploy.sh bootstrap_kvm.sh bash ./deploy.sh --noup_script -i -u "${LAB_UPLINK}" -t "${RELEASE}" +if [ -f "${LAB_FILES}/scripts/bootstrap_kvm.sh" ]; then + bash -c 'FLAGS_TRUE=0; FLAGS_FALSE=1; . ./deploy.sh && . "$1" && kvm_public_segment "${FLAGS_FALSE}" "${FLAGS_TRUE}" br-000000 br-public "$2"' \ + lab "${LAB_FILES}/scripts/bootstrap_kvm.sh" "${PUBLIC_VNI}" + echo "lab: segment public posé par le bootstrap_kvm.sh de l'arbre courant (VNI ${PUBLIC_VNI})" +fi for binary in "${LAB_FILES}"/bin/*; do [ -f "${binary}" ] || continue name=$(basename "${binary}") diff --git a/test/e2e/topologies/scripts/.gitkeep b/test/e2e/topologies/scripts/.gitkeep new file mode 100644 index 0000000..e69de29 From 0841b6de908966127319bfef68b8ebb334e3e262 Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 23:36:14 +0100 Subject: [PATCH 17/17] f-87: agent: bridge public = interfaces.internet, watchdog du segment #87 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Le veth vp--e rejoint cfg.PublicBridge() (interfaces.internet, br-public par défaut, jamais default_interface). Le watchdog signale un bridge public absent, éteint ou sans port VXLAN. config.exemple.yml : internet: br-public. Signed-off-by: GnomeZworc --- conf/agent/config.exemple.yml | 6 +- internal/config/agent/config_test.go | 17 ++++++ internal/config/agent/interfaces.go | 13 ++++ internal/config/agent/interfaces_test.go | 20 ++++++ internal/netif/link.go | 18 ++++++ internal/vpc/create.go | 2 +- internal/watchdog/check_public.go | 39 ++++++++++++ internal/watchdog/check_public_test.go | 77 ++++++++++++++++++++++++ internal/watchdog/watchdog.go | 3 + internal/watchdog/watchdog_test.go | 8 +++ 10 files changed, 200 insertions(+), 3 deletions(-) create mode 100644 internal/config/agent/interfaces.go create mode 100644 internal/config/agent/interfaces_test.go create mode 100644 internal/watchdog/check_public.go create mode 100644 internal/watchdog/check_public_test.go diff --git a/conf/agent/config.exemple.yml b/conf/agent/config.exemple.yml index e03bc6e..09ab413 100644 --- a/conf/agent/config.exemple.yml +++ b/conf/agent/config.exemple.yml @@ -39,10 +39,12 @@ times: # Bridge interface used when the requested iface_type is not found in interfaces default_interface: br-000000 -# Map of logical interface types to physical bridge names on this host +# Map of logical interface types to physical bridge names on this host. +# internet: public bridge, carrying vxlan-public (deploy.sh --public_vni); every VPC +# plugs its vp--e veth into it. br-public when absent, never default_interface. interfaces: vms: br-000000 - internet: br-000000 + internet: br-public admin: br-000000 # MTU, identical on every hypervisor. diff --git a/internal/config/agent/config_test.go b/internal/config/agent/config_test.go index a4d5b22..d99ec7c 100644 --- a/internal/config/agent/config_test.go +++ b/internal/config/agent/config_test.go @@ -145,4 +145,21 @@ func TestLoadConfig_ExempleFourniEstValide(t *testing.T) { if cfg.QEMU.QMPDir == "" { t.Error("config.exemple.yml devrait définir qemu.qmp_dir") } + if got := cfg.PublicBridge(); got != "br-public" { + t.Errorf("config.exemple.yml : bridge public %q, br-public attendu", got) + } +} + +func TestLoadConfig_PublicBridgeWithoutInternetKey(t *testing.T) { + path := filepath.Join(t.TempDir(), "agent.yml") + if err := os.WriteFile(path, []byte("default_interface: br-000000\ninterfaces:\n lan: br-lan\n"), 0o600); err != nil { + t.Fatal(err) + } + cfg, err := LoadConfig(path) + if err != nil { + t.Fatalf("LoadConfig : %v", err) + } + if got := cfg.PublicBridge(); got != "br-public" { + t.Errorf("bridge public %q, br-public attendu (jamais default_interface)", got) + } } diff --git a/internal/config/agent/interfaces.go b/internal/config/agent/interfaces.go new file mode 100644 index 0000000..67e3163 --- /dev/null +++ b/internal/config/agent/interfaces.go @@ -0,0 +1,13 @@ +package configuration + +const ( + InternetInterface = "internet" + DefaultPublicBridge = "br-public" +) + +func (c Config) PublicBridge() string { + if bridge := c.Interfaces[InternetInterface]; bridge != "" { + return bridge + } + return DefaultPublicBridge +} diff --git a/internal/config/agent/interfaces_test.go b/internal/config/agent/interfaces_test.go new file mode 100644 index 0000000..ef5a0a0 --- /dev/null +++ b/internal/config/agent/interfaces_test.go @@ -0,0 +1,20 @@ +package configuration + +import "testing" + +func TestPublicBridge(t *testing.T) { + cases := map[string]struct { + cfg Config + want string + }{ + "clé absente": {Config{DefaultInterface: "br-000000"}, "br-public"}, + "clé vide": {Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"internet": ""}}, "br-public"}, + "clé posée": {Config{Interfaces: map[string]string{"internet": "br-wan"}}, "br-wan"}, + "autres types, sans default_interface en repli": {Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"lan": "br-lan"}}, "br-public"}, + } + for name, c := range cases { + if got := c.cfg.PublicBridge(); got != c.want { + t.Errorf("%s : %q, %q attendu", name, got, c.want) + } + } +} diff --git a/internal/netif/link.go b/internal/netif/link.go index 56fdb87..8c4b2b0 100644 --- a/internal/netif/link.go +++ b/internal/netif/link.go @@ -46,3 +46,21 @@ func LinkMTU(name string) (int, error) { } return link.Attrs().MTU, nil } + +func BridgeVxlanPorts(bridge string) ([]string, error) { + br, err := netlink.LinkByName(bridge) + if err != nil { + return nil, err + } + links, err := netlink.LinkList() + if err != nil { + return nil, err + } + var ports []string + for _, l := range links { + if l.Attrs().MasterIndex == br.Attrs().Index && l.Type() == "vxlan" { + ports = append(ports, l.Attrs().Name) + } + } + return ports, nil +} diff --git a/internal/vpc/create.go b/internal/vpc/create.go index c0377bf..8b31911 100644 --- a/internal/vpc/create.go +++ b/internal/vpc/create.go @@ -32,7 +32,7 @@ func CreateVPC(db *badger.DB, name string, cfg *configuration.Config) error { return err } - if err := netif.BridgeSetMaster("vp-"+vpcID+"-e", "br-public"); err != nil { + if err := netif.BridgeSetMaster("vp-"+vpcID+"-e", cfg.PublicBridge()); err != nil { return err } diff --git a/internal/watchdog/check_public.go b/internal/watchdog/check_public.go new file mode 100644 index 0000000..8752688 --- /dev/null +++ b/internal/watchdog/check_public.go @@ -0,0 +1,39 @@ +package watchdog + +import ( + "fmt" + + configuration "git.g3e.fr/syonad/two/internal/config/agent" + "git.g3e.fr/syonad/two/internal/netif" + "git.g3e.fr/syonad/two/internal/watchdog/notify" +) + +const kindPublic = "public" + +type publicProbe interface { + LinkProblem(name string) string + VxlanPorts(bridge string) ([]string, error) +} + +type systemPublicProbe struct{} + +func (systemPublicProbe) LinkProblem(name string) string { return linkProblem(name) } + +func (systemPublicProbe) VxlanPorts(bridge string) ([]string, error) { + return netif.BridgeVxlanPorts(bridge) +} + +func CheckPublicSegment(cfg *configuration.Config, p publicProbe, n notify.Notifier) { + bridge := cfg.PublicBridge() + if problem := p.LinkProblem(bridge); problem != "" { + n.Notify(kindPublic, bridge, problem+" (public bridge, interfaces.internet): the vpcs of this host have no public segment") + return + } + ports, err := p.VxlanPorts(bridge) + switch { + case err != nil: + n.Notify(kindPublic, bridge, fmt.Sprintf("vxlan ports unreadable: %v", err)) + case len(ports) == 0: + n.Notify(kindPublic, bridge, "no vxlan port: the public segment is unreachable from this host") + } +} diff --git a/internal/watchdog/check_public_test.go b/internal/watchdog/check_public_test.go new file mode 100644 index 0000000..f8c0ea8 --- /dev/null +++ b/internal/watchdog/check_public_test.go @@ -0,0 +1,77 @@ +package watchdog + +import ( + "errors" + "testing" + + configuration "git.g3e.fr/syonad/two/internal/config/agent" +) + +type fakePublicProbe struct { + problems map[string]string + ports []string + err error + asked []string +} + +func (f *fakePublicProbe) LinkProblem(name string) string { + f.asked = append(f.asked, name) + return f.problems[name] +} + +func (f *fakePublicProbe) VxlanPorts(bridge string) ([]string, error) { + f.asked = append(f.asked, "ports:"+bridge) + return f.ports, f.err +} + +func TestCheckPublicSegment_SilentWithAVxlanPort(t *testing.T) { + r := &recorder{} + p := &fakePublicProbe{ports: []string{"vxlan-public"}} + CheckPublicSegment(&configuration.Config{}, p, r) + if len(r.calls) != 0 { + t.Errorf("notifications = %+v, aucune attendue", r.calls) + } + if len(p.asked) != 2 || p.asked[0] != "br-public" || p.asked[1] != "ports:br-public" { + t.Errorf("sondes = %q, br-public attendu par défaut", p.asked) + } +} + +func TestCheckPublicSegment_FollowsInterfacesInternet(t *testing.T) { + r := &recorder{} + p := &fakePublicProbe{ports: []string{"vxlan-public"}} + CheckPublicSegment(&configuration.Config{DefaultInterface: "br-000000", Interfaces: map[string]string{"internet": "br-wan"}}, p, r) + if len(p.asked) != 2 || p.asked[0] != "br-wan" || p.asked[1] != "ports:br-wan" { + t.Errorf("sondes = %q, br-wan attendu", p.asked) + } +} + +func TestCheckPublicSegment_ReportsAMissingBridgeWithoutReadingPorts(t *testing.T) { + r := &recorder{} + p := &fakePublicProbe{problems: map[string]string{"br-public": "interface br-public not found: Link not found"}} + CheckPublicSegment(&configuration.Config{}, p, r) + got := r.forName("br-public") + want := "interface br-public not found: Link not found (public bridge, interfaces.internet): the vpcs of this host have no public segment" + if len(got) != 1 || got[0].kind != "public" || got[0].problem != want { + t.Fatalf("notifications = %+v, une attendue : %q", r.calls, want) + } + if len(p.asked) != 1 { + t.Errorf("ports lus alors que le bridge manque : %q", p.asked) + } +} + +func TestCheckPublicSegment_ReportsABridgeWithoutVxlan(t *testing.T) { + r := &recorder{} + CheckPublicSegment(&configuration.Config{}, &fakePublicProbe{}, r) + got := r.forName("br-public") + if len(got) != 1 || got[0].problem != "no vxlan port: the public segment is unreachable from this host" { + t.Errorf("notifications = %+v", r.calls) + } +} + +func TestCheckPublicSegment_ReportsUnreadablePorts(t *testing.T) { + r := &recorder{} + CheckPublicSegment(&configuration.Config{}, &fakePublicProbe{err: errors.New("netlink: permission denied")}, r) + if !r.hasProblemContaining("vxlan ports unreadable: netlink: permission denied") { + t.Errorf("notifications = %+v", r.calls) + } +} diff --git a/internal/watchdog/watchdog.go b/internal/watchdog/watchdog.go index 7a0101f..b49b12c 100644 --- a/internal/watchdog/watchdog.go +++ b/internal/watchdog/watchdog.go @@ -23,6 +23,7 @@ type Watchdog struct { interval time.Duration dbusDown bool l3 l3Probe + public publicProbe } func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *slog.Logger, interval time.Duration) *Watchdog { @@ -41,6 +42,7 @@ func New(db *badger.DB, cfg *configuration.Config, n notify.Notifier, logger *sl logger: logger, interval: interval, l3: systemProbe{frr: frr.NewClient()}, + public: systemPublicProbe{}, } } @@ -74,6 +76,7 @@ func (w *Watchdog) tick() { if err := CheckVMs(w.db, w.cfg, u, w.notifier); err != nil { w.logger.Error("watchdog: vm check failed", "err", err) } + CheckPublicSegment(w.cfg, w.public, w.notifier) CheckBGP(w.cfg, w.l3, w.notifier) if err := CheckL3VPCs(w.db, w.cfg, w.l3, w.notifier); err != nil { w.logger.Error("watchdog: l3 vpc check failed", "err", err) diff --git a/internal/watchdog/watchdog_test.go b/internal/watchdog/watchdog_test.go index eb43975..87fcfb6 100644 --- a/internal/watchdog/watchdog_test.go +++ b/internal/watchdog/watchdog_test.go @@ -74,6 +74,13 @@ func TestNew_IntervalleValideConserve(t *testing.T) { } } +func TestNew_ChecksThePublicSegmentOnTheSystem(t *testing.T) { + w := New(newTestDB(t), testCfg(t), &recorder{}, nil, time.Second) + if _, ok := w.public.(systemPublicProbe); !ok { + t.Errorf("sonde du segment public = %T, systemPublicProbe attendue", w.public) + } +} + func TestNew_LoggerNil(t *testing.T) { w := New(newTestDB(t), testCfg(t), &recorder{}, nil, time.Second) if w.logger == nil { @@ -141,6 +148,7 @@ func TestRun_ErreurDeBaseLogueeEtBoucleContinue(t *testing.T) { n := newChanNotifier() l, buf := testLogger() w := New(db, testCfg(t), n, l, 10*time.Millisecond) + w.public = &fakePublicProbe{ports: []string{"vxlan-public"}} ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond) defer cancel()