Compare commits

..

No commits in common. "da6295baf1f31316c9fbc6b80db5aabeaf1d8249" and "aeb5ddc1bc91f669ecc22c435a28cb899d2d87aa" have entirely different histories.

22 changed files with 103 additions and 698 deletions

View file

@ -91,7 +91,7 @@ paths:
"404":
$ref: "#/components/responses/NotFound"
"409":
description: VPC not deletable — only running or error states can be deleted, and all its subnets must be deleted or deleting; subnets still deleting are awaited by the asynchronous deletion
description: VPC not deletable — only running or error states can be deleted, and all its subnets must be deleted first
content:
application/json:
schema:
@ -289,7 +289,7 @@ paths:
"404":
$ref: "#/components/responses/NotFound"
"409":
description: Subnet not deletable — only running or error states can be deleted, and every VM with an interface on it must be deleted or deleting; VMs still deleting are awaited by the asynchronous deletion
description: Subnet not deletable — only running or error states can be deleted, and no VM that is not deleted may still have an interface on it
content:
application/json:
schema:

View file

@ -19,22 +19,12 @@ worker:
# Maximum number of commands queued before Dispatch blocks
buffer_size: 100
# Timing (in seconds) for commands that wait on resource state transitions
times:
# Graceful VM shutdown before QMP quit
timeout_vms_stop: 300
# Interval between two system_powerdown during the shutdown
next_vms_shutdown: 30
# Subnet deletion: wait for its VMs still deleting
timeout_subnet_stop: 360
# VPC deletion: wait for its subnets still deleting
timeout_vpc_stop: 420
# Subnet creation: wait for its VPC to be running
timeout_subnet_start: 300
# VM creation: wait for the subnets of its interfaces to be running
timeout_vms_start: 300
# Interval between each state check
poll_interval: 2
# Timing for commands that wait on resource state transitions
dispatcher:
# How long (in seconds) to wait before giving up
timeout_seconds: 300
# Interval (in seconds) between each state check
poll_seconds: 2
# Bridge interface used when the requested iface_type is not found in interfaces
default_interface: br-000000

View file

@ -50,8 +50,7 @@ QEMU et VM
exécuté par le processus appelant et hérite du netns posé par ``netns.Call``. Une unit
transitoire, forkée par PID 1, démarrerait dans le netns racine et ne verrait pas le tap.
* L'arrêt d'une VM ne touche **jamais** aux fichiers disque. En revanche, un ``quit`` brutal est
envoyé à l'expiration de ``times.timeout_vms_stop``. ``system_powerdown`` est renvoyé toutes les
``times.next_vms_shutdown`` : un appui ACPI arrivé avant que l'invité sache le traiter est perdu.
envoyé à l'expiration de ``dispatcher.timeout_seconds``.
Arrêt de l'agent
----------------

View file

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

View file

@ -48,7 +48,7 @@ La réponse est un **202** : la création est acceptée, pas terminée.
Un subnet peut être demandé dès maintenant : il est accepté tant que le VPC est en ``creating``
ou ``running``, et sa création attend que le VPC soit ``running``, dans la limite de
``times.timeout_subnet_start``. Il n'est refusé en **422** que si le VPC est absent, en ``error``
``dispatcher.timeout_seconds``. Il n'est refusé en **422** que si le VPC est absent, en ``error``
ou en ``deleting``. Le modèle d'attente est décrit dans :doc:`/exploitation/api-agent/asynchronisme`.
2. Le subnet

View file

@ -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, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom
- machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, recréation sous le même nom
- hv1
- #41, #84, #79
- #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
@ -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'à 480 s, au-delà du ``times.timeout_vpc_stop`` par défaut (420 s).
attend jusqu'à 360 s.
Hypothèses vérifiées en lab, à garder en tête en écrivant un test :

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

@ -418,7 +418,7 @@ func TestDeleteSubnetCommand_Prepare_RefusedWhileAVMUsesIt(t *testing.T) {
kv.AddInDB(db, "vm/i-c/state", "running")
kv.AddInDB(db, "vm/i-c/nic/0/subnet", "sn-a")
err := DeleteSubnetCommand{Name: "sn-a"}.Prepare(db, nil)
if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-c`) {
if err == nil || !strings.Contains(err.Error(), `subnet "sn-a" is still used by vms i-a, i-b, i-c`) {
t.Fatalf("erreur %v", err)
}
if s, _ := kv.GetFromDB(db, "subnet/sn-a/state"); s != "running" {

View file

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

View file

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

View file

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

View file

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

View file

@ -1,7 +1,6 @@
package vm
import (
"encoding/json"
"errors"
"fmt"
"io/fs"
@ -50,7 +49,13 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error {
if _, err := os.Stat(socketPath); err == nil {
// socket présent : tenter l'arrêt gracieux
shutdownQEMU(qmp.Send, socketPath, cfg.Times.VMsStop(), cfg.Times.VMsShutdown(), cfg.Times.Poll())
if _, err := qmp.Send(socketPath, []string{`{"execute":"system_powerdown"}`}); err == nil {
waitQMPDead(socketPath,
time.Duration(cfg.Dispatcher.TimeoutSeconds)*time.Second,
time.Duration(cfg.Dispatcher.PollSeconds)*time.Second,
)
}
// connexion QMP échouée : QEMU déjà mort
}
// socket absent ou QEMU déjà arrêté : cleanup direct
@ -110,31 +115,15 @@ func removeDHCPFiles(d vmData, name string, backend dhcpbackend.Backend) error {
return nil
}
type qmpSender func(socketPath string, commands []string) ([]json.RawMessage, error)
const (
qmpPowerdown = `{"execute":"system_powerdown"}`
qmpQuit = `{"execute":"quit"}`
)
func shutdownQEMU(send qmpSender, socketPath string, timeout, resend, poll time.Duration) {
if _, err := send(socketPath, []string{qmpPowerdown}); err != nil {
return
}
deadline := time.After(timeout)
again := time.NewTicker(resend)
defer again.Stop()
func waitQMPDead(socketPath string, timeout, poll time.Duration) {
timer := time.After(timeout)
for {
select {
case <-deadline:
send(socketPath, []string{qmpQuit})
case <-timer:
qmp.Send(socketPath, []string{`{"execute":"quit"}`})
return
case <-again.C:
if _, err := send(socketPath, []string{qmpPowerdown}); err != nil {
return
}
case <-time.After(poll):
if _, err := send(socketPath, nil); err != nil {
if _, err := qmp.Send(socketPath, nil); err != nil {
return
}
}

View file

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

View file

@ -1,19 +1,5 @@
# 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
@ -30,13 +16,6 @@
(disque absent par exemple), il pouvait laisser `<vm>.sock` dans `serial_dir`, `monitor_dir` ou
`qmp_dir`, que la suppression de la VM ne retirait pas. Les trois sont désormais supprimés une
fois QEMU arrêté ; un fichier absent n'est pas une erreur
- **`system_powerdown` est renvoyé toutes les `next_vms_shutdown` secondes (#79)** pendant
l'arrêt d'une VM, jusqu'à `timeout_vms_stop`. Un seul appui était envoyé : arrivé avant que
l'invité sache le traiter (firmware, chargeur de démarrage), il était perdu, et la suppression
durait les 300 s du délai avant un `quit` brutal (mesuré en lab)
- **La suppression d'un VPC échoue si l'un de ses subnets échoue (#79).** Elle attendait qu'aucun
subnet ne soit plus en `deleting`, puis supprimait le VPC même si un subnet était passé en
`error`. Il en va de même pour un subnet dont une VM attendue passe en `error`
## Mise à jour depuis la 0.2.0
@ -48,7 +27,3 @@
la fuite vers l'underlay décrite plus haut reste possible. Pour la fermer sans recréer le VPC,
la poser à la main sur chaque hyperviseur, la table étant le `l3vni` du VPC :
`ip route replace unreachable default metric 4278198272 table <l3vni>`
- **La section `dispatcher` n'est plus lue** : restée dans `/etc/two/agent.yml`, elle est ignorée,
et les valeurs par défaut de `times` s'appliquent. Une valeur personnalisée de
`dispatcher.timeout_seconds` est à reporter dans `times.timeout_vms_stop` (et dans les délais
qui en dépendent)

View file

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

View file

@ -1,6 +1,6 @@
# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, sockets QEMU d'une VM en error retirés, dépendances VM → subnet → VPC, suppression d'un subnet en attente de ses VM, arrêt d'une VM juste démarrée par renvoi de system_powerdown, recréation sous le même nom
# fonctionnalité: machine d'états — 409 pendant creating, suppression depuis error, 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, #84, #79
# tickets: #41, #84
on hv1 <<'NODE'
check "VPC vp-t12a" vpc_create vp-t12a 10.12.0.0/16
@ -41,16 +41,4 @@ check "sn-t12a recréé puis supprimé" wait_state subnets/sn-t12a deleted
check "suppression de vp-t12a, sans subnet, 202 (témoin)" expect_code 202 api_code DELETE vpcs/vp-t12a
check "vp-t12a supprimé" wait_state vpcs/vp-t12a deleted
check "vp-t12a recréé sous le même nom" vpc_create vp-t12a 10.12.0.0/16
check "subnet sn-t12q (VNI 1202)" subnet_create sn-t12q vp-t12a 1202 10.12.2.0/24
check "VM t12-q" vm_create t12-q sn-t12q 10.12.2.10
sleep 3
T12Q=$(date +%s)
check "t12-q : suppression 3 s après running, 202" expect_code 202 api_code DELETE vms/t12-q
check "sn-t12q : suppression envoyée aussitôt, acceptée malgré t12-q en deleting, 202" expect_code 202 api_code DELETE subnets/sn-t12q
info "sn-t12q juste après sa suppression : $(api_state subnets/sn-t12q), t12-q : $(api_state vms/t12-q)"
check "t12-q supprimée" wait_state vms/t12-q deleted
check "sn-t12q supprimé après t12-q" wait_state subnets/sn-t12q deleted
info "t12-q puis sn-t12q supprimés en $(( $(date +%s) - T12Q )) s"
check "t12-q : arrêtée bien avant times.timeout_vms_stop (300 s), par un system_powerdown renvoyé si le premier est perdu" test "$(( $(date +%s) - T12Q ))" -lt 200
NODE