syonad/two
2
0
Fork 0
Code Issues 17 Pull requests 1 Projects Releases 4 Packages Wiki Activity Actions

f-37: code: use state and check state #37

Browse source 
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
This commit is contained in:
GnomeZworc 2026-08-13 23:37:46 +02:00
commit 576166f3f1
Signed by: nicolas.boufideline
GPG key ID: 4406BBBF8845D632
6 changed files with 179 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

28
internal/dispatcher/agent/subnet_commands.go
View file

@ -6,6 +6,7 @@ import (
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/state"
"git.g3e.fr/syonad/two/internal/subnet"
"git.g3e.fr/syonad/two/pkg/db/kv"
"github.com/dgraph-io/badger/v4"
@ -34,18 +35,18 @@ func (c CreateSubnetCommand) Prepare(db *badger.DB, cfg *configuration.Config) e
if _, err := kv.GetFromDB(db, "subnet/"+c.Name+"/state"); err == nil {
return fmt.Errorf("subnet %q already exists", c.Name)
}
vpcState, err := kv.GetFromDB(db, "vpc/"+c.VPC+"/state")
vpcState, err := state.Get(db, "vpc/"+c.VPC)
if err != nil {
return fmt.Errorf("vpc %q not found", c.VPC)
}
if vpcState == "deleting" || vpcState == "deleted" {
if vpcState != state.Creating && vpcState != state.Running {
return fmt.Errorf("vpc %q is %s", c.VPC, vpcState)
}
localIface, ok := cfg.Interfaces[c.IfaceType]
if !ok {
localIface = cfg.DefaultInterface
}
kv.AddInDB(db, "subnet/"+c.Name+"/state", "creating")
state.Set(db, c.Key(), state.Creating)
kv.AddInDB(db, "subnet/"+c.Name+"/vpc", c.VPC)
kv.AddInDB(db, "subnet/"+c.Name+"/mode", c.Mode)
kv.AddInDB(db, "subnet/"+c.Name+"/local_iface", localIface)
@ -61,16 +62,19 @@ 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 {
state, err := kv.GetFromDB(db, "vpc/"+c.VPC+"/state")
vpcState, err := state.Get(db, "vpc/"+c.VPC)
if err != nil {
return fmt.Errorf("vpc %q not found while waiting", c.VPC)
}
if state == "created" {
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 created", c.VPC)
return fmt.Errorf("timed out waiting for vpc %q to be running", c.VPC)
case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second):
}
}
@ -84,21 +88,25 @@ type DeleteSubnetCommand struct {
func (c DeleteSubnetCommand) Key() string { return "subnet/" + c.Name }
func (c DeleteSubnetCommand) Prepare(db *badger.DB, _ *configuration.Config) error {
if _, err := kv.GetFromDB(db, "subnet/"+c.Name+"/state"); err != nil {
current, err := state.Get(db, c.Key())
if err != nil {
return fmt.Errorf("subnet %q not found", c.Name)
}
return kv.AddInDB(db, "subnet/"+c.Name+"/state", "deleting")
if !state.CanDelete(current) {
return fmt.Errorf("subnet %q cannot be deleted while %s", c.Name, current)
}
return state.Set(db, c.Key(), state.Deleting)
}
func (c DeleteSubnetCommand) Execute(db *badger.DB, _ *configuration.Config) error {
if err := subnet.DeleteSubnet(db, c.Name); err != nil {
return err
}
state, err := kv.GetFromDB(db, "subnet/"+c.Name+"/state")
current, err := state.Get(db, c.Key())
if err != nil {
return err
}
if state == "deleted" {
if current == state.Deleted {
kv.DeleteInDB(db, "subnet/"+c.Name)
}
return nil

50
internal/dispatcher/agent/subnet_commands_test.go
View file

@ -17,7 +17,7 @@ func testCfg() *configuration.Config {
func TestCreateSubnetCommand_Prepare_Success(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", VxlanID: 100,
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -37,7 +37,7 @@ func TestCreateSubnetCommand_Prepare_Success(t *testing.T) {
func TestCreateSubnetCommand_Prepare_UsesIfaceTypeMapping(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", VxlanID: 100,
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -51,7 +51,7 @@ func TestCreateSubnetCommand_Prepare_UsesIfaceTypeMapping(t *testing.T) {
func TestCreateSubnetCommand_Prepare_UsesDefaultIfaceWhenTypeUnknown(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", VxlanID: 100,
IfaceType: "inconnu", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -65,8 +65,8 @@ func TestCreateSubnetCommand_Prepare_UsesDefaultIfaceWhenTypeUnknown(t *testing.
func TestCreateSubnetCommand_Prepare_Duplicate(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "subnet/sn-exist/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
kv.AddInDB(db, "subnet/sn-exist/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-exist", VPC: "vpc-1", VxlanID: 100,
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -113,7 +113,7 @@ func TestCreateSubnetCommand_Prepare_VPCDeleted(t *testing.T) {
func TestCreateSubnetCommand_Prepare_DefaultsToVxlanMode(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", VxlanID: 100,
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -130,7 +130,7 @@ func TestCreateSubnetCommand_Prepare_DefaultsToVxlanMode(t *testing.T) {
func TestCreateSubnetCommand_Prepare_BridgeMode_Success(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", Mode: "bridge",
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -150,7 +150,7 @@ func TestCreateSubnetCommand_Prepare_BridgeMode_Success(t *testing.T) {
func TestCreateSubnetCommand_Prepare_BridgeMode_NoVxlanID(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", Mode: "bridge",
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -163,7 +163,7 @@ func TestCreateSubnetCommand_Prepare_BridgeMode_NoVxlanID(t *testing.T) {
func TestCreateSubnetCommand_Prepare_UnknownMode(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", Mode: "vlan",
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -175,7 +175,7 @@ func TestCreateSubnetCommand_Prepare_UnknownMode(t *testing.T) {
func TestCreateSubnetCommand_Prepare_DefaultRouteStored(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", VxlanID: 100,
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -195,7 +195,7 @@ func TestCreateSubnetCommand_Prepare_DefaultRouteStored(t *testing.T) {
func TestCreateSubnetCommand_Prepare_DefaultRouteFalseByDefault(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-1/state", "created")
kv.AddInDB(db, "vpc/vpc-1/state", "running")
cmd := CreateSubnetCommand{
Name: "sn-1", VPC: "vpc-1", VxlanID: 100,
IfaceType: "vms", InterfaceIP: "10.0.0.1", CIDR: "10.0.0.0/24",
@ -211,7 +211,7 @@ func TestCreateSubnetCommand_Prepare_DefaultRouteFalseByDefault(t *testing.T) {
func TestDeleteSubnetCommand_Prepare_Success(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-del/state", "created")
kv.AddInDB(db, "subnet/sn-del/state", "running")
cmd := DeleteSubnetCommand{Name: "sn-del"}
if err := cmd.Prepare(db, nil); err != nil {
t.Fatalf("Prepare a échoué : %v", err)
@ -222,6 +222,32 @@ func TestDeleteSubnetCommand_Prepare_Success(t *testing.T) {
}
}
func TestDeleteSubnetCommand_Prepare_RefusedWhileCreating(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-wip/state", "creating")
cmd := DeleteSubnetCommand{Name: "sn-wip"}
if err := cmd.Prepare(db, nil); err == nil {
t.Error("Prepare devrait refuser la suppression d'un subnet en creating")
}
s, _ := kv.GetFromDB(db, "subnet/sn-wip/state")
if s != "creating" {
t.Errorf("l'état ne devrait pas changer, obtenu %q", s)
}
}
func TestDeleteSubnetCommand_Prepare_AllowedFromError(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-ko/state", "error")
cmd := DeleteSubnetCommand{Name: "sn-ko"}
if err := cmd.Prepare(db, nil); err != nil {
t.Fatalf("Prepare devrait accepter un subnet en error : %v", err)
}
s, _ := kv.GetFromDB(db, "subnet/sn-ko/state")
if s != "deleting" {
t.Errorf("state attendu deleting, obtenu %q", s)
}
}
func TestDeleteSubnetCommand_Prepare_NotFound(t *testing.T) {
_, db := newTestDispatcher(t)
cmd := DeleteSubnetCommand{Name: "sn-inexistant"}

28
internal/dispatcher/agent/vm_commands.go
View file

@ -8,6 +8,7 @@ import (
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/state"
"git.g3e.fr/syonad/two/internal/vm"
"git.g3e.fr/syonad/two/pkg/db/kv"
"github.com/dgraph-io/badger/v4"
@ -36,18 +37,18 @@ func (c StartVMCommand) Prepare(db *badger.DB, _ *configuration.Config) error {
if _, err := kv.GetFromDB(db, "vm/"+c.Name+"/state"); err == nil {
return fmt.Errorf("vm %q already exists", c.Name)
}
subnetState, err := kv.GetFromDB(db, "subnet/"+c.Subnet+"/state")
subnetState, err := state.Get(db, "subnet/"+c.Subnet)
if err != nil {
return fmt.Errorf("subnet %q not found", c.Subnet)
}
if subnetState == "deleting" || subnetState == "deleted" {
if subnetState != state.Creating && subnetState != state.Running {
return fmt.Errorf("subnet %q is %s", c.Subnet, subnetState)
}
port, err := allocateMetadataPort(db)
if err != nil {
return fmt.Errorf("allocate metadata port: %w", err)
}
kv.AddInDB(db, "vm/"+c.Name+"/state", "starting")
state.Set(db, c.Key(), state.Creating)
kv.AddInDB(db, "vm/"+c.Name+"/subnet", c.Subnet)
kv.AddInDB(db, "vm/"+c.Name+"/ip", c.IP)
kv.AddInDB(db, "vm/"+c.Name+"/metadata_port", strconv.Itoa(port))
@ -93,16 +94,19 @@ 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)
for {
state, err := kv.GetFromDB(db, "subnet/"+c.Subnet+"/state")
subnetState, err := state.Get(db, "subnet/"+c.Subnet)
if err != nil {
return fmt.Errorf("subnet %q not found while waiting", c.Subnet)
}
if state == "created" {
if subnetState == state.Running {
break
}
if subnetState != state.Creating {
return fmt.Errorf("subnet %q is %s, cannot start vm %q", c.Subnet, subnetState, c.Name)
}
select {
case <-timeout:
return fmt.Errorf("timed out waiting for subnet %q to be created", c.Subnet)
return fmt.Errorf("timed out waiting for subnet %q to be running", c.Subnet)
case <-time.After(time.Duration(cfg.Dispatcher.PollSeconds) * time.Second):
}
}
@ -116,21 +120,25 @@ type StopVMCommand struct {
func (c StopVMCommand) Key() string { return "vm/" + c.Name }
func (c StopVMCommand) Prepare(db *badger.DB, _ *configuration.Config) error {
if _, err := kv.GetFromDB(db, "vm/"+c.Name+"/state"); err != nil {
current, err := state.Get(db, c.Key())
if err != nil {
return fmt.Errorf("vm %q not found", c.Name)
}
return kv.AddInDB(db, "vm/"+c.Name+"/state", "stopping")
if !state.CanDelete(current) {
return fmt.Errorf("vm %q cannot be stopped while %s", c.Name, current)
}
return state.Set(db, c.Key(), state.Deleting)
}
func (c StopVMCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
if err := vm.StopVM(db, c.Name, cfg); err != nil {
return err
}
state, err := kv.GetFromDB(db, "vm/"+c.Name+"/state")
current, err := state.Get(db, c.Key())
if err != nil {
return err
}
if state == "stopped" {
if current == state.Deleted {
kv.DeleteInDB(db, "vm/"+c.Name)
}
return nil

55
internal/dispatcher/agent/vm_commands_test.go
View file

@ -10,7 +10,7 @@ import (
func TestStartVMCommand_Prepare_SingleDisk(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-1/state", "created")
kv.AddInDB(db, "subnet/sn-1/state", "running")
kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1")
cmd := StartVMCommand{
@ -34,7 +34,7 @@ func TestStartVMCommand_Prepare_SingleDisk(t *testing.T) {
func TestStartVMCommand_Prepare_MultiDisk(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-1/state", "created")
kv.AddInDB(db, "subnet/sn-1/state", "running")
kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1")
cmd := StartVMCommand{
@ -66,7 +66,7 @@ func TestStartVMCommand_Prepare_MultiDisk(t *testing.T) {
func TestStartVMCommand_Prepare_SlotGap(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-1/state", "created")
kv.AddInDB(db, "subnet/sn-1/state", "running")
kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1")
// sdb absent au boot — slot réservé pour hotplug
@ -96,7 +96,7 @@ func TestStartVMCommand_Prepare_SlotGap(t *testing.T) {
func TestStartVMCommand_Prepare_NoVolumePath(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "subnet/sn-1/state", "created")
kv.AddInDB(db, "subnet/sn-1/state", "running")
kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-1")
cmd := StartVMCommand{
@ -114,9 +114,54 @@ func TestStartVMCommand_Prepare_NoVolumePath(t *testing.T) {
}
}
// --- StopVMCommand.Prepare ---
func TestStopVMCommand_Prepare_Success(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vm/vm-run/state", "running")
cmd := StopVMCommand{Name: "vm-run"}
if err := cmd.Prepare(db, nil); err != nil {
t.Fatalf("Prepare a échoué : %v", err)
}
s, _ := kv.GetFromDB(db, "vm/vm-run/state")
if s != "deleting" {
t.Errorf("state attendu deleting, obtenu %q", s)
}
}
func TestStopVMCommand_Prepare_RefusedWhileCreating(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vm/vm-wip/state", "creating")
cmd := StopVMCommand{Name: "vm-wip"}
if err := cmd.Prepare(db, nil); err == nil {
t.Error("Prepare devrait refuser l'arrêt d'une VM en creating")
}
s, _ := kv.GetFromDB(db, "vm/vm-wip/state")
if s != "creating" {
t.Errorf("l'état ne devrait pas changer, obtenu %q", s)
}
}
func TestStopVMCommand_Prepare_AllowedFromError(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vm/vm-ko/state", "error")
cmd := StopVMCommand{Name: "vm-ko"}
if err := cmd.Prepare(db, nil); err != nil {
t.Fatalf("Prepare devrait accepter une VM en error : %v", err)
}
}
func TestStopVMCommand_Prepare_NotFound(t *testing.T) {
_, db := newTestDispatcher(t)
cmd := StopVMCommand{Name: "vm-inexistante"}
if err := cmd.Prepare(db, nil); err == nil {
t.Error("Prepare devrait échouer si la VM n'existe pas")
}
}
func TestStartVMCommand_Prepare_Duplicate(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vm/vm-exist/state", "started")
kv.AddInDB(db, "vm/vm-exist/state", "running")
cmd := StartVMCommand{
Name: "vm-exist",

23
internal/dispatcher/agent/vpc_commands.go
View file

@ -7,6 +7,7 @@ import (
"time"
configuration "git.g3e.fr/syonad/two/internal/config/agent"
"git.g3e.fr/syonad/two/internal/state"
"git.g3e.fr/syonad/two/internal/vpc"
"git.g3e.fr/syonad/two/pkg/db/kv"
"github.com/dgraph-io/badger/v4"
@ -29,7 +30,7 @@ func (c CreateVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error
if err := kv.AddInDB(db, "vpc/"+c.Name+"/cidr", c.CIDR); err != nil {
return err
}
return kv.AddInDB(db, "vpc/"+c.Name+"/state", "creating")
return state.Set(db, c.Key(), state.Creating)
}
func (c CreateVPCCommand) Execute(db *badger.DB, _ *configuration.Config) error {
@ -43,9 +44,13 @@ type DeleteVPCCommand struct {
func (c DeleteVPCCommand) Key() string { return "vpc/" + c.Name }
func (c DeleteVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error {
if _, err := kv.GetFromDB(db, "vpc/"+c.Name+"/state"); err != nil {
current, err := state.Get(db, c.Key())
if err != nil {
return fmt.Errorf("vpc %q not found", c.Name)
}
if !state.CanDelete(current) {
return fmt.Errorf("vpc %q cannot be deleted while %s", c.Name, current)
}
entries, err := kv.ListByPrefix(db, "subnet/")
if err != nil {
return fmt.Errorf("failed to list subnets: %w", err)
@ -55,12 +60,12 @@ func (c DeleteVPCCommand) Prepare(db *badger.DB, _ *configuration.Config) error
continue
}
subnetName := strings.Split(key, "/")[1]
state, err := kv.GetFromDB(db, "subnet/"+subnetName+"/state")
if err != nil || (state != "deleting" && state != "deleted") {
s, err := state.Get(db, "subnet/"+subnetName)
if err != nil || (s != state.Deleting && s != state.Deleted) {
return fmt.Errorf("subnet %q must be deleted before deleting vpc %q", subnetName, c.Name)
}
}
return kv.AddInDB(db, "vpc/"+c.Name+"/state", "deleting")
return state.Set(db, c.Key(), state.Deleting)
}
func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) error {
@ -74,8 +79,8 @@ func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) erro
for key, value := range entries {
if strings.HasSuffix(key, "/vpc") && value == c.Name {
subnetName := strings.Split(key, "/")[1]
state, _ := kv.GetFromDB(db, "subnet/"+subnetName+"/state")
if state == "deleting" {
s, _ := state.Get(db, "subnet/"+subnetName)
if s == state.Deleting {
pending = true
break
}
@ -93,11 +98,11 @@ func (c DeleteVPCCommand) Execute(db *badger.DB, cfg *configuration.Config) erro
if err := vpc.DeleteVPC(db, c.Name); err != nil {
return err
}
state, err := kv.GetFromDB(db, "vpc/"+c.Name+"/state")
current, err := state.Get(db, c.Key())
if err != nil {
return err
}
if state == "deleted" {
if current == state.Deleted {
kv.DeleteInDB(db, "vpc/"+c.Name)
}
return nil

47
internal/dispatcher/agent/vpc_commands_test.go
View file

@ -32,7 +32,7 @@ func TestCreateVPCCommand_Prepare_NewVPC(t *testing.T) {
func TestCreateVPCCommand_Prepare_Duplicate(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-exist/state", "created")
kv.AddInDB(db, "vpc/vpc-exist/state", "running")
cmd := CreateVPCCommand{Name: "vpc-exist", CIDR: "10.0.0.0/16"}
if err := cmd.Prepare(db, nil); err == nil {
t.Error("Prepare devrait échouer sur un VPC déjà existant")
@ -51,7 +51,7 @@ func TestCreateVPCCommand_Prepare_InvalidCIDR(t *testing.T) {
func TestDeleteVPCCommand_Prepare_Success(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-del/state", "created")
kv.AddInDB(db, "vpc/vpc-del/state", "running")
cmd := DeleteVPCCommand{Name: "vpc-del"}
if err := cmd.Prepare(db, nil); err != nil {
t.Fatalf("Prepare a échoué : %v", err)
@ -70,10 +70,45 @@ func TestDeleteVPCCommand_Prepare_NotFound(t *testing.T) {
}
}
func TestDeleteVPCCommand_Prepare_RefusedWhileCreating(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-wip/state", "creating")
cmd := DeleteVPCCommand{Name: "vpc-wip"}
if err := cmd.Prepare(db, nil); err == nil {
t.Error("Prepare devrait refuser la suppression d'un VPC en creating")
}
s, _ := kv.GetFromDB(db, "vpc/vpc-wip/state")
if s != "creating" {
t.Errorf("l'état ne devrait pas changer, obtenu %q", s)
}
}
func TestDeleteVPCCommand_Prepare_RefusedWhileDeleting(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-gone/state", "deleting")
cmd := DeleteVPCCommand{Name: "vpc-gone"}
if err := cmd.Prepare(db, nil); err == nil {
t.Error("Prepare devrait refuser un VPC déjà en deleting")
}
}
func TestDeleteVPCCommand_Prepare_AllowedFromError(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-ko/state", "error")
cmd := DeleteVPCCommand{Name: "vpc-ko"}
if err := cmd.Prepare(db, nil); err != nil {
t.Fatalf("Prepare devrait accepter un VPC en error : %v", err)
}
s, _ := kv.GetFromDB(db, "vpc/vpc-ko/state")
if s != "deleting" {
t.Errorf("state attendu deleting, obtenu %q", s)
}
}
func TestDeleteVPCCommand_Prepare_BlockedByActiveSubnet(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-busy/state", "created")
kv.AddInDB(db, "subnet/sn-1/state", "created")
kv.AddInDB(db, "vpc/vpc-busy/state", "running")
kv.AddInDB(db, "subnet/sn-1/state", "running")
kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-busy")
cmd := DeleteVPCCommand{Name: "vpc-busy"}
if err := cmd.Prepare(db, nil); err == nil {
@ -83,7 +118,7 @@ func TestDeleteVPCCommand_Prepare_BlockedByActiveSubnet(t *testing.T) {
func TestDeleteVPCCommand_Prepare_AllowedWhenSubnetDeleted(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-ok/state", "created")
kv.AddInDB(db, "vpc/vpc-ok/state", "running")
kv.AddInDB(db, "subnet/sn-1/state", "deleted")
kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-ok")
cmd := DeleteVPCCommand{Name: "vpc-ok"}
@ -94,7 +129,7 @@ func TestDeleteVPCCommand_Prepare_AllowedWhenSubnetDeleted(t *testing.T) {
func TestDeleteVPCCommand_Prepare_AllowedWhenSubnetDeleting(t *testing.T) {
_, db := newTestDispatcher(t)
kv.AddInDB(db, "vpc/vpc-ok/state", "created")
kv.AddInDB(db, "vpc/vpc-ok/state", "running")
kv.AddInDB(db, "subnet/sn-1/state", "deleting")
kv.AddInDB(db, "subnet/sn-1/vpc", "vpc-ok")
cmd := DeleteVPCCommand{Name: "vpc-ok"}