Update STACKIT SDK

platform/api/stackit/helper.go

@@ -1,12 +1,12 @@
 package stackit
 
 import (
-	"github.com/stackitcloud/stackit-sdk-go/services/iaas"
+	iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api"
 	"k8s.io/utils/ptr"
 )
 
-func createNullableString(s string) *iaas.NullableString {
+func createNullableString(s string) iaas.NullableString {
 	n := iaas.NullableString{}
 	n.Set(ptr.To(s))
-	return &n
+	return n
 }

platform/machine/stackit/cluster.go

@@ -13,15 +13,15 @@ import (
 	"github.com/flatcar/mantle/platform/api/stackit"
 	"github.com/flatcar/mantle/platform/conf"
 	"github.com/flatcar/mantle/util"
-	"github.com/stackitcloud/stackit-sdk-go/services/iaas"
 	"k8s.io/utils/ptr"
 )
 
 type cluster struct {
 	*platform.BaseCluster
-	flight  *flight
-	network *stackit.Network
-	keypair *stackit.Keypair
+	flight   *flight
+	network  *stackit.Network
+	keypair  *stackit.Keypair
+	secGroup *stackit.SecurityGroup
 }
 
 func (bc *cluster) NewMachine(userdata *conf.UserData) (platform.Machine, error) {
@@ -38,30 +38,17 @@ func (bc *cluster) NewMachine(userdata *conf.UserData) (platform.Machine, error)
 	base64Config := make([]byte, base64.StdEncoding.EncodedLen(len(userDataConf.Bytes())))
 	base64.StdEncoding.Encode(base64Config, userDataConf.Bytes())
 
-	secGroup, err := bc.flight.api.CreateSecurityGroup(ctx, "flatcar_security_group")
-	if err != nil {
-		return nil, fmt.Errorf("error creating security group: %w", err)
-	}
-	err = bc.flight.api.CreateSecurityGroupRuleTCP(ctx, *secGroup.Id)
-	if err != nil {
-		return nil, fmt.Errorf("error creating security group rule: %w", err)
-	}
-	err = bc.flight.api.CreateSecurityGroupRuleUDP(ctx, *secGroup.Id)
-	if err != nil {
-		return nil, fmt.Errorf("error creating security group rule: %w", err)
-	}
-
 	ipAddress, err := bc.flight.api.CreateIPAddress(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("error creating IP address: %w", err)
 	}
 
-	var keyPairName iaas.CreateServerPayloadGetKeypairNameAttributeType
+	var keyPairName *string
 	if bc.keypair != nil {
 		keyPairName = bc.keypair.Name
 	}
-	securityGoups := &[]string{*secGroup.Id}
-	instance, err := bc.flight.api.CreateServer(ctx, bc.vmname(), bc.network.Id, securityGoups, keyPairName, &base64Config)
+	securityGoups := []string{*bc.secGroup.Id}
+	instance, err := bc.flight.api.CreateServer(ctx, bc.vmname(), ptr.To(bc.network.Id), securityGoups, keyPairName, ptr.To(string(base64Config)))
 	if err != nil {
 		return nil, fmt.Errorf("creating server: %w", err)
 	}
@@ -133,17 +120,27 @@ func (bc *cluster) NewMachine(userdata *conf.UserData) (platform.Machine, error)
 
 }
 
-func (bc *cluster) vmname() iaas.CreateServerPayloadGetNameAttributeType {
+func (bc *cluster) vmname() string {
 	b := make([]byte, 5)
 	rand.Read(b)
-	return ptr.To(fmt.Sprintf("%s-%x", bc.Name()[0:13], b))
+	return fmt.Sprintf("%s-%x", bc.Name()[0:13], b)
 }
 
 func (bc *cluster) Destroy() {
 	bc.BaseCluster.Destroy()
+	if bc.secGroup != nil {
+		// The security group can only be deleted once it is no longer
+		// referenced by any server, which may take a moment after the
+		// machines have been destroyed.
+		if err := util.Retry(5, 10*time.Second, func() error {
+			return bc.flight.api.DeleteSecurityGroup(context.TODO(), *bc.secGroup.Id)
+		}); err != nil {
+			plog.Errorf("deleting security group %v: %v", *bc.secGroup.Id, err)
+		}
+	}
 	if bc.network != nil {
-		if err := bc.flight.api.DeleteNetwork(context.TODO(), *bc.network.Id); err != nil {
-			plog.Errorf("deleting network %v: %v", *bc.network.Name, err)
+		if err := bc.flight.api.DeleteNetwork(context.TODO(), bc.network.Id); err != nil {
+			plog.Errorf("deleting network %v: %v", bc.network.Name, err)
 		}
 	}
 

platform/machine/stackit/flight.go

@@ -78,6 +78,17 @@ func (bf *flight) NewCluster(rconf *platform.RuntimeConfig) (platform.Cluster, e
 		return nil, fmt.Errorf("creating network for cluster: %w", err)
 	}
 
+	c.secGroup, err = bf.api.CreateSecurityGroup(context.Background(), bc.Name())
+	if err != nil {
+		return nil, fmt.Errorf("creating security group for cluster: %w", err)
+	}
+	if err := bf.api.CreateSecurityGroupRuleTCP(context.Background(), *c.secGroup.Id); err != nil {
+		return nil, fmt.Errorf("creating security group rule: %w", err)
+	}
+	if err := bf.api.CreateSecurityGroupRuleUDP(context.Background(), *c.secGroup.Id); err != nil {
+		return nil, fmt.Errorf("creating security group rule: %w", err)
+	}
+
 	bf.AddCluster(c)
 
 	return c, nil

platform/machine/stackit/machine.go

@@ -2,12 +2,10 @@ package stackit
 
 import (
 	"context"
-	"time"
 
 	"github.com/flatcar/mantle/platform"
 	"github.com/flatcar/mantle/platform/api/stackit"
-	"github.com/flatcar/mantle/util"
-	"github.com/stackitcloud/stackit-sdk-go/services/iaas"
+	iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api"
 	"golang.org/x/crypto/ssh"
 )
 
@@ -24,21 +22,17 @@ func (bm *machine) ID() string {
 }
 
 func (bm *machine) IP() string {
-	if bm.mach.Nics != nil && len(*bm.mach.Nics) > 0 {
-		for _, nic := range *bm.mach.Nics {
-			if nic.HasPublicIp() {
-				return *nic.PublicIp
-			}
+	for _, nic := range bm.mach.Nics {
+		if nic.HasPublicIp() {
+			return *nic.PublicIp
 		}
 	}
 	return ""
 }
 
 func (bm *machine) PrivateIP() string {
-	if bm.mach.Nics != nil && len(*bm.mach.Nics) > 0 {
-		for _, nic := range *bm.mach.Nics {
-			return *nic.Ipv4
-		}
+	for _, nic := range bm.mach.Nics {
+		return *nic.Ipv4
 	}
 	return ""
 }
@@ -73,28 +67,14 @@ func (bm *machine) Destroy() {
 
 	nics := []iaas.ServerNetwork{}
 	if server != nil {
-		nics = *server.Nics
+		nics = server.Nics
 	}
 
 	for _, nic := range nics {
-		for _, securityGroupID := range *nic.SecurityGroups {
+		for _, securityGroupID := range nic.SecurityGroups {
 			if err := bm.cluster.flight.api.RemoveSecurityGroupFromServer(ctx, server.GetId(), securityGroupID); err != nil {
 				plog.Errorf("error removing security group from server: %s", err)
 			}
-			securityGroup, err := bm.cluster.flight.api.GetSecurityGroup(ctx, securityGroupID)
-			if err != nil {
-				plog.Errorf("error getting security group: %s", err)
-			}
-			for _, securityGroupRule := range securityGroup.GetRules() {
-				if err := bm.cluster.flight.api.DeleteSecurityGroupRule(ctx, securityGroupID, *securityGroupRule.Id); err != nil {
-					plog.Errorf("error deleting security group rule: %s", err)
-				}
-			}
-			if err := util.Retry(5, 10*time.Second, func() error {
-				return bm.cluster.flight.api.DeleteSecurityGroup(ctx, securityGroupID)
-			}); err != nil {
-				plog.Errorf("error deleting security group: %s", err)
-			}
 		}
 		networkID := nic.GetNetworkId()
 		if err := bm.cluster.flight.api.RemoveNetworkFromServer(ctx, server.GetId(), networkID); err != nil {