diff --git a/cloud/cleanup.go b/cloud/cleanup.go index 83ccbfe..67b391a 100644 --- a/cloud/cleanup.go +++ b/cloud/cleanup.go @@ -12,62 +12,86 @@ package cloud import ( "context" + "errors" "fmt" - "maps" - "strings" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/publicip" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" ) +type cleanupScope struct { + Client + tags map[string]string +} + // CleanupByTags deletes provider-managed cloud resources matching tags without // relying on Kubernetes objects. Load balancers are deleted before servers so -// server deletion is not blocked by target attachments. +// server deletion is not blocked by target attachments, servers are deleted +// before security groups so attached servers do not block security group +// deletion if server detachment fails or lags, and networks are deleted last. func CleanupByTags(ctx context.Context, client Client, tags map[string]string) error { if len(tags) == 0 { - return fmt.Errorf("%w: empty cleanup tag selector", ErrInvalidInput) + return fmt.Errorf("%w: empty cleanup tag selector", shared.ErrInvalidInput) } - var errs []string - bastionTags := make(map[string]string, len(tags)+1) - maps.Copy(bastionTags, tags) - bastionTags["cluster-api-provider-stackit/resource-role"] = "bastion" - if err := client.DeleteBastion(ctx, BastionInput{Tags: bastionTags}, Bastion{}); err != nil && !IsNotFound(err) { - errs = append(errs, fmt.Sprintf("delete bastion resources: %v", err)) + scope := &cleanupScope{ + Client: client, + tags: tags, } - - loadBalancers, err := client.ListAPIServerLoadBalancersByTags(ctx, tags) - if err != nil { - errs = append(errs, err.Error()) - } else { - for _, loadBalancer := range loadBalancers { - if err := client.DeleteAPIServerLoadBalancer(ctx, loadBalancer.ID); err != nil && !IsNotFound(err) { - errs = append(errs, fmt.Sprintf("delete load balancer %q: %v", loadBalancer.ID, err)) - } + var errs []error + for _, deleteFn := range []func(context.Context) error{ + publicip.New(scope).Delete, + loadbalancer.New(scope).Delete, + server.New(scope).Delete, + securitygroup.New(scope).Delete, + network.New(scope).Delete, + } { + if err := deleteFn(ctx); err != nil { + errs = append(errs, err) } } - servers, err := client.ListServersByTags(ctx, tags) - if err != nil { - errs = append(errs, err.Error()) - } else { - for _, server := range servers { - if err := client.DeleteServer(ctx, server.ID); err != nil && !IsNotFound(err) { - errs = append(errs, fmt.Sprintf("delete server %q: %v", server.ID, err)) - } - } + if len(errs) > 0 { + return fmt.Errorf("%w: %w", shared.ErrTransient, errors.Join(errs...)) } + return nil +} - networks, err := client.ListNetworksByTags(ctx, tags) - if err != nil { - errs = append(errs, err.Error()) - } else { - for _, net := range networks { - if err := client.DeleteNetwork(ctx, net.ID); err != nil && !IsNotFound(err) { - errs = append(errs, fmt.Sprintf("delete network %q: %v", net.ID, err)) - } - } +func (s *cleanupScope) PublicIPSpec() publicip.PublicIPSpec { + return publicip.PublicIPSpec{ + Tags: s.tags, + ServerSelector: s.tags, } +} - if len(errs) > 0 { - return fmt.Errorf("%w: %s", ErrTransient, strings.Join(errs, "; ")) +func (s *cleanupScope) LoadBalancerSpec() loadbalancer.LoadBalancerSpec { + return loadbalancer.LoadBalancerSpec{ + Tags: s.tags, + } +} + +func (s *cleanupScope) ServerSpec() server.ServerSpec { + return server.ServerSpec{ + Tags: s.tags, + } +} + +func (s *cleanupScope) SecurityGroupSpecs() []securitygroup.SecurityGroupSpec { + return []securitygroup.SecurityGroupSpec{ + { + Tags: s.tags, + ServerSelector: s.tags, + }, + } +} + +func (s *cleanupScope) NetworkSpec() network.NetworkSpec { + return network.NetworkSpec{ + Tags: s.tags, + Managed: true, } - return nil } diff --git a/cloud/cleanup_test.go b/cloud/cleanup_test.go index 9a5da79..a4902e6 100644 --- a/cloud/cleanup_test.go +++ b/cloud/cleanup_test.go @@ -12,12 +12,158 @@ package cloud_test import ( "context" + "fmt" + "maps" "testing" "github.com/stackitcloud/cluster-api-provider-stackit/cloud" cloudfake "github.com/stackitcloud/cluster-api-provider-stackit/cloud/fake" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/publicip" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" + "github.com/stackitcloud/cluster-api-provider-stackit/util" ) +type testResourceScope struct { + cloud.Client + networkSpec network.NetworkSpec + serverSpec server.ServerSpec + publicIPSpec publicip.PublicIPSpec + loadBalancerSpec loadbalancer.LoadBalancerSpec + securityGroupSpec []securitygroup.SecurityGroupSpec +} + +func (s *testResourceScope) NetworkSpec() network.NetworkSpec { + return s.networkSpec +} + +func (s *testResourceScope) ServerSpec() server.ServerSpec { + return s.serverSpec +} + +func (s *testResourceScope) PublicIPSpec() publicip.PublicIPSpec { + return s.publicIPSpec +} + +func (s *testResourceScope) LoadBalancerSpec() loadbalancer.LoadBalancerSpec { + return s.loadBalancerSpec +} + +func (s *testResourceScope) SecurityGroupSpecs() []securitygroup.SecurityGroupSpec { + return s.securityGroupSpec +} + +func createTestResources(t *testing.T, client cloud.Client, prefix string, tags map[string]string) { + t.Helper() + ctx := context.Background() + + var networkID string + if err := network.New(&testResourceScope{ + Client: client, + networkSpec: network.NetworkSpec{ + Name: prefix + "-net", + IPv4Prefix: network.DefaultNetworkPrefix, + Tags: tags, + Managed: true, + SetNetwork: func(net *network.Network, _ bool) { + networkID = net.ID + }, + }, + }).Reconcile(ctx); err != nil { + t.Fatalf("network.Reconcile() error = %v", err) + } + + var workerServerID, bastionServerID string + if err := server.New(&testResourceScope{ + Client: client, + serverSpec: server.ServerSpec{ + Name: prefix + "-worker", + ImageID: "22222222-2222-4222-8222-222222222222", + MachineType: "c2i.2", + NetworkID: networkID, + Tags: tags, + SetServer: func(srv *server.Server, _ bool) { + workerServerID = srv.ID + }, + }, + }).Reconcile(ctx); err != nil { + t.Fatalf("server.Reconcile(worker) error = %v", err) + } + + bastionTags := make(map[string]string, len(tags)+1) + maps.Copy(bastionTags, tags) + bastionTags[util.LabelResourceRole] = util.ResourceRoleBastion + if err := server.New(&testResourceScope{ + Client: client, + serverSpec: server.ServerSpec{ + Name: prefix + "-bastion", + ImageID: "22222222-2222-4222-8222-222222222222", + MachineType: "c2i.2", + NetworkID: networkID, + Tags: bastionTags, + SetServer: func(srv *server.Server, _ bool) { + bastionServerID = srv.ID + }, + }, + }).Reconcile(ctx); err != nil { + t.Fatalf("server.Reconcile(bastion) error = %v", err) + } + + if err := publicip.New(&testResourceScope{ + Client: client, + publicIPSpec: publicip.PublicIPSpec{ + Tags: bastionTags, + ServerID: bastionServerID, + }, + }).Reconcile(ctx); err != nil { + t.Fatalf("publicip.Reconcile() error = %v", err) + } + + nodeSSHTags := make(map[string]string, len(tags)+1) + maps.Copy(nodeSSHTags, tags) + nodeSSHTags[util.LabelResourceRole] = util.ResourceRoleNodeSSH + if err := securitygroup.New(&testResourceScope{ + Client: client, + securityGroupSpec: []securitygroup.SecurityGroupSpec{ + { + Name: prefix + "-bastion-sg", + Tags: bastionTags, + ServerIDs: []string{bastionServerID}, + }, + { + Name: prefix + "-node-ssh-sg", + Tags: nodeSSHTags, + ServerIDs: []string{workerServerID}, + Rules: []securitygroup.Rule{ + { + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 22, + PortMax: 22, + RemoteSecurityGroupTags: bastionTags, + }, + }, + }, + }, + }).Reconcile(ctx); err != nil { + t.Fatalf("securitygroup.Reconcile() error = %v", err) + } + + if err := loadbalancer.New(&testResourceScope{ + Client: client, + loadBalancerSpec: loadbalancer.LoadBalancerSpec{ + Name: prefix + "-apiserver", + NetworkID: networkID, + Port: loadbalancer.DefaultAPIServerPort, + Tags: tags, + }, + }).Reconcile(ctx); err != nil { + t.Fatalf("loadbalancer.Reconcile() error = %v", err) + } +} + func TestCleanupByTagsDeletesMatchingCloudResources(t *testing.T) { ctx := context.Background() client := cloudfake.New() @@ -30,80 +176,74 @@ func TestCleanupByTagsDeletesMatchingCloudResources(t *testing.T) { "cluster-api-provider-stackit/test-id": "test-2", } - if _, err := client.CreateServer(ctx, cloud.CreateServerInput{Name: "matched", Tags: tags}); err != nil { - t.Fatalf("CreateServer() error = %v", err) + createTestResources(t, client, "matched", tags) + createTestResources(t, client, "other", otherTags) + + if err := cloud.CleanupByTags(ctx, client, tags); err != nil { + t.Fatalf("CleanupByTags() error = %v", err) } - if _, err := client.CreateServer(ctx, cloud.CreateServerInput{Name: "other", Tags: otherTags}); err != nil { - t.Fatalf("CreateServer() error = %v", err) + + if got := client.ServerCount(); got != 2 { + t.Fatalf("remaining server count = %d, want 2", got) } - if _, err := client.EnsureAPIServerLoadBalancer(ctx, cloud.LoadBalancerInput{ - Name: "matched", - Tags: tags, - NetworkID: "network-id", - Port: 6443, - Targets: []cloud.LoadBalancerTargetInput{{ - Name: "target", - IP: "10.0.0.10", - }}, - }); err != nil { - t.Fatalf("EnsureAPIServerLoadBalancer() error = %v", err) + if got := client.LoadBalancerCount(); got != 1 { + t.Fatalf("remaining load balancer count = %d, want 1", got) } - if _, err := client.EnsureAPIServerLoadBalancer(ctx, cloud.LoadBalancerInput{ - Name: "other", - Tags: otherTags, - NetworkID: "network-id", - Port: 6443, - Targets: []cloud.LoadBalancerTargetInput{{ - Name: "target", - IP: "10.0.0.11", - }}, - }); err != nil { - t.Fatalf("EnsureAPIServerLoadBalancer() error = %v", err) + if got := client.PublicIPCount(); got != 1 { + t.Fatalf("remaining public IP count = %d, want 1", got) } - if _, err := client.CreateNetwork(ctx, cloud.CreateNetworkInput{Name: "matched-net", Tags: tags}); err != nil { - t.Fatalf("CreateNetwork() error = %v", err) + if got := client.SecurityGroupCount(); got != 2 { + t.Fatalf("remaining security group count = %d, want 2", got) } - if _, err := client.CreateNetwork(ctx, cloud.CreateNetworkInput{Name: "other-net", Tags: otherTags}); err != nil { - t.Fatalf("CreateNetwork() error = %v", err) + if sg := client.FindSecurityGroupByTags(tags); sg != nil { + t.Fatalf("unexpected remaining matched security group: %+v", sg) } - - if err := cloud.CleanupByTags(ctx, client, tags); err != nil { - t.Fatalf("CleanupByTags() error = %v", err) + if sg := client.FindSecurityGroupByTags(otherTags); sg == nil { + t.Fatal("expected other security group to remain") } - - matchedServers, err := client.ListServersByTags(ctx, tags) - if err != nil { - t.Fatalf("ListServersByTags() error = %v", err) + if got := client.NetworkCount(); got != 1 { + t.Fatalf("remaining network count = %d, want 1", got) } - if len(matchedServers) != 0 { - t.Fatalf("matched server count = %d, want 0", len(matchedServers)) + if net := client.FindNetworkByTags(tags); net != nil { + t.Fatalf("unexpected remaining matched network: %+v", net) } - otherServers, err := client.ListServersByTags(ctx, otherTags) - if err != nil { - t.Fatalf("ListServersByTags(other) error = %v", err) + if net := client.FindNetworkByTags(otherTags); net == nil { + t.Fatal("expected other network to remain") } - if len(otherServers) != 1 { - t.Fatalf("other server count = %d, want 1", len(otherServers)) +} + +func TestCleanupByTagsContinuesWhenIndividualDeletesFail(t *testing.T) { + ctx := context.Background() + client := cloudfake.New() + tags := map[string]string{ + "cluster-api-provider-stackit/e2e": "true", + "cluster-api-provider-stackit/test-id": "test-partial-fail", } - matchedLoadBalancers, err := client.ListAPIServerLoadBalancersByTags(ctx, tags) - if err != nil { - t.Fatalf("ListAPIServerLoadBalancersByTags() error = %v", err) + + createTestResources(t, client, "matched", tags) + + // Inject a transient failure on the first server delete; the remaining + // server, load balancer, public IP, unattached security group, and network + // should still be cleaned up in the same pass. + client.FailNextDeleteServer = fmt.Errorf("injected server delete failure") + + if err := cloud.CleanupByTags(ctx, client, tags); err == nil { + t.Fatal("CleanupByTags() error = nil, want non-nil when server delete fails") } - if len(matchedLoadBalancers) != 0 { - t.Fatalf("matched load balancer count = %d, want 0", len(matchedLoadBalancers)) + + if got := client.ServerCount(); got != 1 { + t.Fatalf("remaining server count = %d, want 1 (the one that failed to delete)", got) } - matchedNetworks, err := client.ListNetworksByTags(ctx, tags) - if err != nil { - t.Fatalf("ListNetworksByTags() error = %v", err) + if got := client.LoadBalancerCount(); got != 0 { + t.Fatalf("remaining load balancer count = %d, want 0", got) } - if len(matchedNetworks) != 0 { - t.Fatalf("matched network count = %d, want 0", len(matchedNetworks)) + if got := client.PublicIPCount(); got != 0 { + t.Fatalf("remaining public IP count = %d, want 0", got) } - otherNetworks, err := client.ListNetworksByTags(ctx, otherTags) - if err != nil { - t.Fatalf("ListNetworksByTags(other) error = %v", err) + if got := client.SecurityGroupCount(); got != 0 { + t.Fatalf("remaining security group count = %d, want 0", got) } - if len(otherNetworks) != 1 { - t.Fatalf("other network count = %d, want 1", len(otherNetworks)) + if got := client.NetworkCount(); got != 0 { + t.Fatalf("remaining network count = %d, want 0", got) } } diff --git a/cloud/client.go b/cloud/client.go index d48ac99..f44c051 100644 --- a/cloud/client.go +++ b/cloud/client.go @@ -10,62 +10,22 @@ You may obtain a copy of the License at package cloud -import "context" +import ( + "context" -// Client is the abstraction over STACKIT cloud APIs used by the controllers. -// -// Implementations must: -// - return ErrNotFound when a resource does not exist -// - return ErrUnauthorized for permanent auth failures -// - return ErrInvalidInput for permanent input validation errors -// - return ErrConflict for retryable conflict errors -// - return ErrTransient for retryable transient errors -// - be idempotent (CreateServer/EnsureAPIServerLoadBalancer must not produce -// duplicates when a resource with matching tags already exists) -type Client interface { - GetNetwork(ctx context.Context, id string) (*Network, error) - - FindNetworkByTags(ctx context.Context, tags map[string]string) (*Network, error) - - ListNetworksByTags(ctx context.Context, tags map[string]string) ([]*Network, error) - - CreateNetwork(ctx context.Context, input CreateNetworkInput) (*Network, error) - - DeleteNetwork(ctx context.Context, id string) error - - GetServer(ctx context.Context, id string) (*Server, error) - - FindServerByTags(ctx context.Context, tags map[string]string) (*Server, error) - - ListServersByTags(ctx context.Context, tags map[string]string) ([]*Server, error) - - CreateServer(ctx context.Context, input CreateServerInput) (*Server, error) + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + lb "github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/v2api" +) - DeleteServer(ctx context.Context, id string) error - - EnsureBastion(ctx context.Context, input BastionInput) (*Bastion, error) - - DeleteBastion(ctx context.Context, input BastionInput, status Bastion) error - - EnsureNodeSSHAccess(ctx context.Context, input NodeSSHAccessInput) (*SecurityGroup, error) - - DeleteNodeSSHAccess(ctx context.Context, tags map[string]string) error - - ListPublicIPsByTags(ctx context.Context, tags map[string]string) ([]*PublicIP, error) - - ListSecurityGroupsByTags(ctx context.Context, tags map[string]string) ([]*SecurityGroup, error) - - EnsureAPIServerLoadBalancer(ctx context.Context, input LoadBalancerInput) (*LoadBalancer, error) - - ListAPIServerLoadBalancersByTags(ctx context.Context, tags map[string]string) ([]*LoadBalancer, error) +// Client provides the target STACKIT project, region, and SDK API clients. +type Client interface { + ProjectID() string - // SetAPIServerLoadBalancerTargets replaces the contents of the API-server - // target pool. STACKIT rejects an empty pool. - SetAPIServerLoadBalancerTargets(ctx context.Context, loadBalancerID string, port int32, targets []LoadBalancerTargetInput) error + Region() string - DeleteAPIServerLoadBalancer(ctx context.Context, id string) error + IaaSClient() *iaas.APIClient - ListAvailabilityZones(ctx context.Context) ([]string, error) + LoadBalancerClient() *lb.APIClient } // Factory builds a Client from credentials (raw bytes from the configured diff --git a/cloud/errors_test.go b/cloud/errors_test.go deleted file mode 100644 index e1b82f3..0000000 --- a/cloud/errors_test.go +++ /dev/null @@ -1,56 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package cloud - -import ( - "fmt" - "testing" -) - -func TestErrorClassification(t *testing.T) { - if !IsNotFound(fmt.Errorf("wrapped: %w", ErrNotFound)) { - t.Fatal("IsNotFound() = false, want true") - } - if !IsUnauthorized(fmt.Errorf("wrapped: %w", ErrUnauthorized)) { - t.Fatal("IsUnauthorized() = false, want true") - } - if !IsInvalidInput(fmt.Errorf("wrapped: %w", ErrInvalidInput)) { - t.Fatal("IsInvalidInput() = false, want true") - } - if !IsConflict(fmt.Errorf("wrapped: %w", ErrConflict)) { - t.Fatal("IsConflict() = false, want true") - } - if !IsTransient(fmt.Errorf("wrapped: %w", ErrTransient)) { - t.Fatal("IsTransient() = false, want true") - } -} - -func TestIsRetryable(t *testing.T) { - tests := []struct { - name string - err error - want bool - }{ - {name: "conflict", err: ErrConflict, want: true}, - {name: "transient", err: ErrTransient, want: true}, - {name: "not found", err: ErrNotFound, want: false}, - {name: "unauthorized", err: ErrUnauthorized, want: false}, - {name: "invalid input", err: ErrInvalidInput, want: false}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - if got := IsRetryable(tt.err); got != tt.want { - t.Fatalf("IsRetryable() = %t, want %t", got, tt.want) - } - }) - } -} diff --git a/cloud/fake/client.go b/cloud/fake/client.go index 39128f0..de8b555 100644 --- a/cloud/fake/client.go +++ b/cloud/fake/client.go @@ -14,17 +14,25 @@ package fake import ( "context" + "encoding/base64" + "encoding/json" "fmt" "maps" + "net/http" + "net/http/httptest" "slices" + "strings" "sync" - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" -) - -const ( - bootstrapTargetName = "capi-bootstrap-placeholder" - bootstrapTargetIP = "10.0.0.1" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/publicip" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" + "github.com/stackitcloud/stackit-sdk-go/core/config" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + lb "github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/v2api" ) // Client is an in-memory implementation of cloud.Client. @@ -36,33 +44,38 @@ type Client struct { publicIPs map[string]*publicIPEntry securityGroups map[string]*securityGroupEntry networks map[string]*networkEntry + iaasClient *iaas.APIClient + lbClient *lb.APIClient nextID int // failure injection: if non-nil, the next call returns this error and the // field is cleared. - FailNextCreateServer error - FailNextDeleteServer error - FailNextGetServer error - FailNextFindServer error - FailNextEnsureLB error - FailNextDeleteLB error - FailNextSetTargets error - FailNextGetNetwork error - FailNextCreateNetwork error - FailNextDeleteNetwork error - FailNextEnsureBastion error - FailNextDeleteBastion error - FailNextEnsureNodeSSH error - FailNextDeleteNodeSSH error - FailNextListAZ error + FailNextCreateServer error + FailNextDeleteServer error + FailNextGetServer error + FailNextFindServer error + FailNextEnsureLB error + FailNextDeleteLB error + FailNextSetTargets error + FailNextGetNetwork error + FailNextCreateNetwork error + FailNextDeleteNetwork error + FailNextAddSecurityGroup error + FailNextListAZ error + FailNextGetPublicIP error + FailNextListPublicIPs error + FailNextCreatePublicIP error + FailNextDeletePublicIP error + FailNextAddPublicIP error + FailNextRemovePublicIP error // AvailabilityZones is returned by ListAvailabilityZones if non-empty. // Defaults to eu01-1, eu01-2, eu01-3. AvailabilityZones []string - // LastCreateServerInput records the most recent input passed to CreateServer. - LastCreateServerInput cloud.CreateServerInput + // LastCreateServerInput records the most recent spec passed to CreateServer. + LastCreateServerInput server.ServerSpec // Before* hooks, if non-nil, run before the call they belong to. They let a // test observe API server state at the exact moment a cloud call would @@ -72,43 +85,47 @@ type Client struct { // CreateServerCalls counts successful CreateServer calls (for idempotency // assertions). - CreateServerCalls int - EnsureBastionCalls int - EnsureNodeSSHCalls int + CreateServerCalls int + AddSecurityGroupCalls int } type serverEntry struct { - server *cloud.Server + server *server.Server tags map[string]string securityGroups map[string]struct{} userData []byte } type lbEntry struct { - lb *cloud.LoadBalancer + lb *loadbalancer.LoadBalancer tags map[string]string targets map[string]string } type publicIPEntry struct { - publicIP *cloud.PublicIP + publicIP *publicip.PublicIP tags map[string]string } +type securityGroupRuleEntry struct { + id string + securitygroup.Rule +} + type securityGroupEntry struct { - securityGroup *cloud.SecurityGroup - tags map[string]string - allowedCIDRs []string - remoteSecurityGroups []string + securityGroup *securitygroup.SecurityGroup + description string + tags map[string]string + rules map[string]*securityGroupRuleEntry } type networkEntry struct { - network *cloud.Network + network *network.Network tags map[string]string } // New returns a Client preconfigured with the given networks. -func New(networks ...cloud.Network) *Client { +func New(networks ...network.Network) *Client { c := &Client{ servers: make(map[string]*serverEntry), loadBalancers: make(map[string]*lbEntry), @@ -122,9 +139,44 @@ func New(networks ...cloud.Network) *Client { network: &n, } } + iaasClient, err := iaas.NewAPIClient( + config.WithoutAuthentication(), + config.WithHTTPClient(&http.Client{Transport: roundTripperFunc(c.roundTripIaaS)}), + config.WithEndpoint("http://stackit.fake.local"), + ) + if err != nil { + panic(fmt.Sprintf("create fake iaas client: %v", err)) + } + c.iaasClient = iaasClient + + lbClient, err := lb.NewAPIClient( + config.WithoutAuthentication(), + config.WithHTTPClient(&http.Client{Transport: roundTripperFunc(c.roundTripLB)}), + config.WithEndpoint("http://stackit.fake.local"), + ) + if err != nil { + panic(fmt.Sprintf("create fake loadbalancer client: %v", err)) + } + c.lbClient = lbClient return c } +func (c *Client) ProjectID() string { + return "00000000-0000-0000-0000-000000000000" +} + +func (c *Client) Region() string { + return "eu01" +} + +func (c *Client) IaaSClient() *iaas.APIClient { + return c.iaasClient +} + +func (c *Client) LoadBalancerClient() *lb.APIClient { + return c.lbClient +} + func consume(p *error) error { if *p == nil { return nil @@ -136,513 +188,147 @@ func consume(p *error) error { func (c *Client) genID() string { c.nextID++ - return fmt.Sprintf("fake-%d", c.nextID) -} - -func (c *Client) GetServer(_ context.Context, id string) (*cloud.Server, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if err := consume(&c.FailNextGetServer); err != nil { - return nil, err - } - entry, ok := c.servers[id] - if !ok { - return nil, fmt.Errorf("server %q: %w", id, cloud.ErrNotFound) - } - return cloneServer(entry.server), nil -} - -func (c *Client) FindServerByTags(_ context.Context, tags map[string]string) (*cloud.Server, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if err := consume(&c.FailNextFindServer); err != nil { - return nil, err - } - if len(tags) == 0 { - return nil, fmt.Errorf("empty tags: %w", cloud.ErrNotFound) - } - for _, entry := range c.servers { - if mapContains(entry.tags, tags) { - return cloneServer(entry.server), nil - } - } - return nil, fmt.Errorf("no server matching tags: %w", cloud.ErrNotFound) -} - -func (c *Client) ListServersByTags(_ context.Context, tags map[string]string) ([]*cloud.Server, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if len(tags) == 0 { - return nil, fmt.Errorf("empty tags: %w", cloud.ErrInvalidInput) - } - servers := []*cloud.Server{} - for _, entry := range c.servers { - if mapContains(entry.tags, tags) { - servers = append(servers, cloneServer(entry.server)) - } - } - return servers, nil + return fmt.Sprintf("00000000-0000-4000-8000-%012d", c.nextID) } -// CreateServer creates a server. To satisfy spec section 20 (idempotency), -// it returns the existing server if one with matching tags already exists. -func (c *Client) CreateServer(_ context.Context, input cloud.CreateServerInput) (*cloud.Server, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if c.BeforeCreateServer != nil { - c.BeforeCreateServer() - } - if err := consume(&c.FailNextCreateServer); err != nil { - return nil, err - } - for _, entry := range c.servers { - if len(input.Tags) > 0 && mapContains(entry.tags, input.Tags) { - return cloneServer(entry.server), nil - } - } - +func (c *Client) createServerEntry(input server.ServerSpec) *serverEntry { id := c.genID() c.LastCreateServerInput = input zone := input.AvailabilityZone if zone == "" { zone = "eu01-1" } - server := &cloud.Server{ + srv := &server.Server{ ID: id, Name: input.Name, State: "ACTIVE", AvailabilityZone: zone, - Addresses: []cloud.Address{ + Addresses: []server.Address{ {Type: "InternalIP", Address: "10.0.0.10"}, }, } - c.servers[id] = &serverEntry{ - server: server, + entry := &serverEntry{ + server: srv, tags: copyTags(input.Tags), securityGroups: securityGroupSet(input.SecurityGroups), userData: append([]byte(nil), input.UserData...), } + c.servers[id] = entry c.CreateServerCalls++ - return cloneServer(server), nil -} - -// DeleteServer removes a server. It returns nil if the server is already gone. -func (c *Client) DeleteServer(_ context.Context, id string) error { - c.mu.Lock() - defer c.mu.Unlock() - - if err := consume(&c.FailNextDeleteServer); err != nil { - return err - } - delete(c.servers, id) - return nil + return entry } -func (c *Client) GetNetwork(_ context.Context, id string) (*cloud.Network, error) { +func (c *Client) GetNetwork(_ context.Context, id string) (*network.Network, error) { c.mu.Lock() - defer c.mu.Unlock() - if c.BeforeGetNetwork != nil { + c.mu.Unlock() c.BeforeGetNetwork() + c.mu.Lock() } + defer c.mu.Unlock() + if err := consume(&c.FailNextGetNetwork); err != nil { return nil, err } entry, ok := c.networks[id] if !ok { - return nil, fmt.Errorf("network %q: %w", id, cloud.ErrNotFound) + return nil, fmt.Errorf("network %q: %w", id, shared.ErrNotFound) } out := *entry.network return &out, nil } -func (c *Client) FindNetworkByTags(_ context.Context, tags map[string]string) (*cloud.Network, error) { - c.mu.Lock() - defer c.mu.Unlock() - - matched := c.networksByTags(tags) - if len(matched) == 0 { - return nil, fmt.Errorf("%w: no network matching tags", cloud.ErrNotFound) - } - if len(matched) > 1 { - return nil, fmt.Errorf("%w: multiple networks matching tags", cloud.ErrConflict) - } - out := *matched[0] - return &out, nil -} - -func (c *Client) ListNetworksByTags(_ context.Context, tags map[string]string) ([]*cloud.Network, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if len(tags) == 0 { - return nil, fmt.Errorf("%w: empty tag selector", cloud.ErrInvalidInput) - } - matched := c.networksByTags(tags) - out := make([]*cloud.Network, 0, len(matched)) - for _, n := range matched { - copy := *n - out = append(out, ©) - } - return out, nil -} - -func (c *Client) networksByTags(tags map[string]string) []*cloud.Network { - var matched []*cloud.Network - for _, entry := range c.networks { - if mapContains(entry.tags, tags) { - matched = append(matched, entry.network) - } - } - return matched -} - -func (c *Client) CreateNetwork(_ context.Context, input cloud.CreateNetworkInput) (*cloud.Network, error) { +func (c *Client) getPublicIP(_ context.Context, id string) (*publicip.PublicIP, error) { c.mu.Lock() defer c.mu.Unlock() - if err := consume(&c.FailNextCreateNetwork); err != nil { + if err := consume(&c.FailNextGetPublicIP); err != nil { return nil, err } - if input.Name == "" { - return nil, fmt.Errorf("%w: network name is required", cloud.ErrInvalidInput) - } - - // Idempotency check matching SDK client behavior - if len(input.Tags) > 0 { - matched := c.networksByTags(input.Tags) - if len(matched) > 1 { - return nil, fmt.Errorf("%w: multiple networks matching tags", cloud.ErrConflict) - } - if len(matched) == 1 { - out := *matched[0] - return &out, nil - } - } - - prefixes := []string{} - if input.IPv4Prefix != "" { - prefixes = []string{input.IPv4Prefix} - } - net := &cloud.Network{ - ID: c.genID(), - Name: input.Name, - IPv4Prefixes: prefixes, + if id == "" { + return nil, fmt.Errorf("public IP ID is empty: %w", shared.ErrInvalidInput) } - c.networks[net.ID] = &networkEntry{ - network: net, - tags: maps.Clone(input.Tags), + entry, ok := c.publicIPs[id] + if !ok { + return nil, fmt.Errorf("public IP %q: %w", id, shared.ErrNotFound) } - out := *net + out := *entry.publicIP return &out, nil } -func (c *Client) DeleteNetwork(_ context.Context, id string) error { - c.mu.Lock() - defer c.mu.Unlock() - - if err := consume(&c.FailNextDeleteNetwork); err != nil { - return err - } - if _, ok := c.networks[id]; !ok { - return fmt.Errorf("network %q: %w", id, cloud.ErrNotFound) - } - delete(c.networks, id) - return nil -} - -func (c *Client) EnsureBastion(_ context.Context, input cloud.BastionInput) (*cloud.Bastion, error) { +func (c *Client) createPublicIP(_ context.Context, tags map[string]string) (*publicip.PublicIP, error) { c.mu.Lock() defer c.mu.Unlock() - if err := consume(&c.FailNextEnsureBastion); err != nil { + if err := consume(&c.FailNextCreatePublicIP); err != nil { return nil, err } - for _, serverEntry := range c.servers { - if len(input.Tags) > 0 && mapContains(serverEntry.tags, input.Tags) { - publicIP := c.publicIPByTags(input.Tags) - securityGroup := c.securityGroupByTags(input.Tags) - return &cloud.Bastion{ - ServerID: serverEntry.server.ID, - ServerState: serverEntry.server.State, - ServerPowerStatus: serverEntry.server.PowerStatus, - PublicIPID: idOfPublicIP(publicIP), - PublicIP: ipOfPublicIP(publicIP), - SecurityGroupID: idOfSecurityGroup(securityGroup), - }, nil - } - } - - securityGroupID := c.genID() - securityGroup := &cloud.SecurityGroup{ - ID: securityGroupID, - Name: input.Name + "-ssh", - } - c.securityGroups[securityGroupID] = &securityGroupEntry{ - securityGroup: securityGroup, - tags: copyTags(input.Tags), - allowedCIDRs: append([]string(nil), input.AllowedCIDRs...), - } - - serverID := c.genID() - server := &cloud.Server{ - ID: serverID, - Name: input.Name, - State: "ACTIVE", - Addresses: []cloud.Address{ - {Type: "InternalIP", Address: "10.0.0.20"}, - }, - } - c.servers[serverID] = &serverEntry{ - server: server, - tags: copyTags(input.Tags), - securityGroups: securityGroupSet([]string{securityGroupID}), - userData: append([]byte(nil), input.CloudInit...), + id := c.genID() + publicIP := &publicip.PublicIP{ + ID: id, + IP: "203.0.113.22", } - - publicIPID := c.genID() - publicIP := &cloud.PublicIP{ - ID: publicIPID, - IP: "203.0.113.22", - NetworkInterfaceID: "fake-nic-" + serverID, + c.publicIPs[id] = &publicIPEntry{ + publicIP: publicIP, + tags: copyTags(tags), } - c.publicIPs[publicIPID] = &publicIPEntry{publicIP: publicIP, tags: copyTags(input.Tags)} - - c.EnsureBastionCalls++ - return &cloud.Bastion{ - ServerID: serverID, - ServerState: server.State, - PublicIPID: publicIPID, - PublicIP: publicIP.IP, - SecurityGroupID: securityGroupID, - }, nil + out := *publicIP + return &out, nil } -func (c *Client) DeleteBastion(_ context.Context, input cloud.BastionInput, status cloud.Bastion) error { +func (c *Client) deletePublicIP(_ context.Context, id string) error { c.mu.Lock() defer c.mu.Unlock() - if err := consume(&c.FailNextDeleteBastion); err != nil { + if err := consume(&c.FailNextDeletePublicIP); err != nil { return err } - if status.ServerID != "" { - delete(c.servers, status.ServerID) - } - if status.PublicIPID != "" { - delete(c.publicIPs, status.PublicIPID) - } - if status.SecurityGroupID != "" { - delete(c.securityGroups, status.SecurityGroupID) - } - for id, entry := range c.servers { - if mapContains(entry.tags, input.Tags) { - delete(c.servers, id) - } - } - for id, entry := range c.publicIPs { - if mapContains(entry.tags, input.Tags) { - delete(c.publicIPs, id) - } + if id == "" { + return fmt.Errorf("public IP ID is empty: %w", shared.ErrInvalidInput) } - for id, entry := range c.securityGroups { - if mapContains(entry.tags, input.Tags) { - delete(c.securityGroups, id) - } + if _, ok := c.publicIPs[id]; !ok { + return fmt.Errorf("public IP %q: %w", id, shared.ErrNotFound) } + delete(c.publicIPs, id) return nil } -func (c *Client) EnsureNodeSSHAccess(_ context.Context, input cloud.NodeSSHAccessInput) (*cloud.SecurityGroup, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if err := consume(&c.FailNextEnsureNodeSSH); err != nil { - return nil, err - } - serverEntry, ok := c.servers[input.ServerID] - if !ok { - return nil, fmt.Errorf("server %q: %w", input.ServerID, cloud.ErrNotFound) - } - securityGroup := c.securityGroupByTags(input.Tags) - if securityGroup == nil { - securityGroup = &cloud.SecurityGroup{ - ID: c.genID(), - Name: input.Name, - } - c.securityGroups[securityGroup.ID] = &securityGroupEntry{ - securityGroup: securityGroup, - tags: copyTags(input.Tags), - remoteSecurityGroups: []string{input.BastionSecurityGroupID}, - } - } else { - entry := c.securityGroups[securityGroup.ID] - if !containsString(entry.remoteSecurityGroups, input.BastionSecurityGroupID) { - entry.remoteSecurityGroups = append(entry.remoteSecurityGroups, input.BastionSecurityGroupID) - } - } - if serverEntry.securityGroups == nil { - serverEntry.securityGroups = map[string]struct{}{} - } - serverEntry.securityGroups[securityGroup.ID] = struct{}{} - c.EnsureNodeSSHCalls++ - out := *securityGroup - return &out, nil -} - -func (c *Client) DeleteNodeSSHAccess(_ context.Context, tags map[string]string) error { +func (c *Client) addPublicIPToServer(_ context.Context, serverID, publicIPID string) error { c.mu.Lock() defer c.mu.Unlock() - if err := consume(&c.FailNextDeleteNodeSSH); err != nil { + if err := consume(&c.FailNextAddPublicIP); err != nil { return err } - for id, entry := range c.securityGroups { - if mapContains(entry.tags, tags) { - delete(c.securityGroups, id) - for _, server := range c.servers { - delete(server.securityGroups, id) - } - } - } - return nil -} - -func (c *Client) ListPublicIPsByTags(_ context.Context, tags map[string]string) ([]*cloud.PublicIP, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if len(tags) == 0 { - return nil, fmt.Errorf("empty tags: %w", cloud.ErrInvalidInput) - } - publicIPs := []*cloud.PublicIP{} - for _, entry := range c.publicIPs { - if mapContains(entry.tags, tags) { - out := *entry.publicIP - publicIPs = append(publicIPs, &out) - } - } - return publicIPs, nil -} - -func (c *Client) ListSecurityGroupsByTags(_ context.Context, tags map[string]string) ([]*cloud.SecurityGroup, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if len(tags) == 0 { - return nil, fmt.Errorf("empty tags: %w", cloud.ErrInvalidInput) - } - securityGroups := []*cloud.SecurityGroup{} - for _, entry := range c.securityGroups { - if mapContains(entry.tags, tags) { - out := *entry.securityGroup - securityGroups = append(securityGroups, &out) - } - } - return securityGroups, nil -} - -func (c *Client) EnsureAPIServerLoadBalancer( - _ context.Context, - input cloud.LoadBalancerInput, -) (*cloud.LoadBalancer, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if err := consume(&c.FailNextEnsureLB); err != nil { - return nil, err - } - for _, entry := range c.loadBalancers { - if len(input.Tags) > 0 && mapContains(entry.tags, input.Tags) { - out := *entry.lb - return &out, nil - } + if serverID == "" || publicIPID == "" { + return fmt.Errorf("server ID and public IP ID are required: %w", shared.ErrInvalidInput) } - id := c.genID() - lb := &cloud.LoadBalancer{ - ID: id, - Name: input.Name, - IP: "203.0.113.10", - Port: input.Port, - } - targets := map[string]string{} - if len(input.Targets) == 0 { - targets[bootstrapTargetName] = bootstrapTargetIP - } else { - for _, target := range input.Targets { - targets[target.Name] = target.IP - } - } - c.loadBalancers[id] = &lbEntry{lb: lb, tags: copyTags(input.Tags), targets: targets} - out := *lb - return &out, nil -} - -func (c *Client) ListAPIServerLoadBalancersByTags( - _ context.Context, - tags map[string]string, -) ([]*cloud.LoadBalancer, error) { - c.mu.Lock() - defer c.mu.Unlock() - - if len(tags) == 0 { - return nil, fmt.Errorf("empty tags: %w", cloud.ErrInvalidInput) + if _, ok := c.servers[serverID]; !ok { + return fmt.Errorf("server %q: %w", serverID, shared.ErrNotFound) } - loadBalancers := []*cloud.LoadBalancer{} - for _, entry := range c.loadBalancers { - if mapContains(entry.tags, tags) { - out := *entry.lb - loadBalancers = append(loadBalancers, &out) - } + entry, ok := c.publicIPs[publicIPID] + if !ok { + return fmt.Errorf("public IP %q: %w", publicIPID, shared.ErrNotFound) } - return loadBalancers, nil + entry.publicIP.NetworkInterfaceID = "fake-nic-" + serverID + return nil } -func (c *Client) SetAPIServerLoadBalancerTargets( - _ context.Context, - loadBalancerID string, - port int32, - targets []cloud.LoadBalancerTargetInput, -) error { +func (c *Client) removePublicIPFromServer(_ context.Context, serverID, publicIPID string) error { c.mu.Lock() defer c.mu.Unlock() - if err := consume(&c.FailNextSetTargets); err != nil { + if err := consume(&c.FailNextRemovePublicIP); err != nil { return err } - if loadBalancerID == "" || port <= 0 { - return fmt.Errorf("load balancer ID and target port are required: %w", cloud.ErrInvalidInput) - } - if len(targets) == 0 { - return fmt.Errorf("at least one target is required: %w", cloud.ErrInvalidInput) + if serverID == "" || publicIPID == "" { + return fmt.Errorf("server ID and public IP ID are required: %w", shared.ErrInvalidInput) } - entry, ok := c.loadBalancers[loadBalancerID] + entry, ok := c.publicIPs[publicIPID] if !ok { - return fmt.Errorf("load balancer %q: %w", loadBalancerID, cloud.ErrNotFound) - } - replaced := make(map[string]string, len(targets)) - for _, target := range targets { - // The real API rejects these; accepting them would hide a regression. - if target.Name == "" || target.IP == "" { - return fmt.Errorf("target name and target IP are required: %w", cloud.ErrInvalidInput) - } - replaced[target.Name] = target.IP - } - entry.targets = replaced - return nil -} - -func (c *Client) DeleteAPIServerLoadBalancer(_ context.Context, id string) error { - c.mu.Lock() - defer c.mu.Unlock() - - if err := consume(&c.FailNextDeleteLB); err != nil { - return err + return fmt.Errorf("public IP %q: %w", publicIPID, shared.ErrNotFound) } - delete(c.loadBalancers, id) + entry.publicIP.NetworkInterfaceID = "" return nil } @@ -668,6 +354,17 @@ func (c *Client) PublicIPCount() int { return len(c.publicIPs) } +// PublicIPAttachedToServer reports whether the public IP is attached to the server (test helper). +func (c *Client) PublicIPAttachedToServer(publicIPID, serverID string) bool { + c.mu.Lock() + defer c.mu.Unlock() + entry, ok := c.publicIPs[publicIPID] + if !ok { + return false + } + return entry.publicIP.NetworkInterfaceID == "fake-nic-"+serverID +} + // SecurityGroupCount returns the number of currently tracked security groups. func (c *Client) SecurityGroupCount() int { c.mu.Lock() @@ -709,57 +406,91 @@ func (c *Client) ServerUserData(serverID string) []byte { return append([]byte(nil), entry.userData...) } -// SecurityGroupRemoteSources returns the remote security groups allowed by the -// fake security group rules. -func (c *Client) SecurityGroupRemoteSources(securityGroupID string) []string { +// FindSecurityGroupByTags returns the single security group matching tags (test helper). +func (c *Client) FindSecurityGroupByTags(tags map[string]string) *securitygroup.SecurityGroup { c.mu.Lock() defer c.mu.Unlock() - entry, ok := c.securityGroups[securityGroupID] - if !ok { - return nil + for _, entry := range c.securityGroups { + if shared.MapContains(entry.tags, tags) { + out := *entry.securityGroup + return &out + } } - return append([]string(nil), entry.remoteSecurityGroups...) + return nil } -// LoadBalancerTargetCount returns the number of targets in one load balancer -// target pool (test helper). -func (c *Client) LoadBalancerTargetCount(id string) int { +// NetworkCount returns the number of currently tracked networks (test helper). +func (c *Client) NetworkCount() int { c.mu.Lock() defer c.mu.Unlock() - entry, ok := c.loadBalancers[id] - if !ok { - return 0 - } - return len(entry.targets) + return len(c.networks) } -// LoadBalancerTargetIPs returns one target pool as name to IP (test helper). -func (c *Client) LoadBalancerTargetIPs(id string) map[string]string { +// FindNetworkByTags returns the single network matching tags (test helper). +func (c *Client) FindNetworkByTags(tags map[string]string) *network.Network { c.mu.Lock() defer c.mu.Unlock() - entry, ok := c.loadBalancers[id] - if !ok { - return nil + for _, entry := range c.networks { + if shared.MapContains(entry.tags, tags) { + out := *entry.network + return &out + } } - return copyTags(entry.targets) + return nil } -// SetLoadBalancerIP updates the IP of a load balancer (test helper). -func (c *Client) SetLoadBalancerIP(id, ip string) { +// DeleteServer removes a server from the fake store by ID (test helper). +func (c *Client) DeleteServer(serverID string) { c.mu.Lock() defer c.mu.Unlock() - if entry, ok := c.loadBalancers[id]; ok { - entry.lb.IP = ip + delete(c.servers, serverID) +} + +// SecurityGroupRules returns the rules currently stored on a fake security group. +func (c *Client) SecurityGroupRules(securityGroupID string) []securitygroup.Rule { + c.mu.Lock() + defer c.mu.Unlock() + entry, ok := c.securityGroups[securityGroupID] + if !ok { + return nil } + rules := make([]securitygroup.Rule, 0, len(entry.rules)) + for _, r := range entry.rules { + rules = append(rules, r.Rule) + } + return rules } -func mapContains(haystack, needle map[string]string) bool { - for k, v := range needle { - if haystack[k] != v { - return false - } +// LoadBalancerTargetCount returns the number of targets in one load balancer +// target pool (test helper). +func (c *Client) LoadBalancerTargetCount(id string) int { + c.mu.Lock() + defer c.mu.Unlock() + entry, ok := c.loadBalancers[id] + if !ok { + return 0 + } + return len(entry.targets) +} + +// LoadBalancerTargetIPs returns one target pool as name to IP (test helper). +func (c *Client) LoadBalancerTargetIPs(id string) map[string]string { + c.mu.Lock() + defer c.mu.Unlock() + entry, ok := c.loadBalancers[id] + if !ok { + return nil + } + return copyTags(entry.targets) +} + +// SetLoadBalancerIP updates the IP of a load balancer (test helper). +func (c *Client) SetLoadBalancerIP(id, ip string) { + c.mu.Lock() + defer c.mu.Unlock() + if entry, ok := c.loadBalancers[id]; ok { + entry.lb.IP = ip } - return true } func copyTags(in map[string]string) map[string]string { @@ -784,68 +515,1157 @@ func securityGroupSet(ids []string) map[string]struct{} { return out } -func containsString(values []string, needle string) bool { - return slices.Contains(values, needle) +func (c *Client) ListAvailabilityZones(_ context.Context) ([]string, error) { + c.mu.Lock() + defer c.mu.Unlock() + if err := consume(&c.FailNextListAZ); err != nil { + return nil, err + } + if len(c.AvailabilityZones) > 0 { + return slices.Clone(c.AvailabilityZones), nil + } + return []string{"eu01-1", "eu01-2", "eu01-3"}, nil +} + +type roundTripperFunc func(*http.Request) (*http.Response, error) + +func (f roundTripperFunc) RoundTrip(r *http.Request) (*http.Response, error) { + return f(r) +} + +func (c *Client) roundTripIaaS(r *http.Request) (*http.Response, error) { + rec := httptest.NewRecorder() + rec.Header().Set("Content-Type", "application/json") + + if c.handlePublicIPRequest(rec, r) || + c.handleSecurityGroupRequest(rec, r) || + c.handleServerRequest(rec, r) || + c.handleNetworkRequest(rec, r) || + c.handleAvailabilityZoneRequest(rec, r) { + return rec.Result(), nil + } + + rec.WriteHeader(http.StatusNotFound) + _ = json.NewEncoder(rec).Encode(map[string]any{"message": "not found"}) + return rec.Result(), nil +} + +func (c *Client) handleNetworkRequest(rec *httptest.ResponseRecorder, r *http.Request) bool { + path := r.URL.Path + + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/networks"): + tags := parseLabelSelector(r.URL.Query().Get("label_selector")) + items, err := c.listNetworkItems(tags) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(map[string]any{"items": items}) + } + return true + + case r.Method == http.MethodPost && strings.HasSuffix(path, "/networks"): + var body struct { + Name string `json:"name"` + Labels map[string]string `json:"labels"` + IPv4 *struct { + Prefix string `json:"prefix"` + } `json:"ipv4"` + } + if r.Body != nil { + _ = json.NewDecoder(r.Body).Decode(&body) + } + var prefix string + if body.IPv4 != nil { + prefix = body.IPv4.Prefix + } + created, err := c.createNetwork(body.Name, prefix, body.Labels) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(created) + } + return true + + case r.Method == http.MethodGet && strings.Contains(path, "/networks/"): + id := path[strings.LastIndex(path, "/networks/")+len("/networks/"):] + got, err := c.getNetworkItem(r.Context(), id) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(got) + } + return true + + case r.Method == http.MethodDelete && strings.Contains(path, "/networks/"): + id := path[strings.LastIndex(path, "/networks/")+len("/networks/"):] + writeFakeStatus(rec, c.deleteNetwork(id)) + return true + + default: + return false + } +} + +func (c *Client) getNetworkItem(ctx context.Context, id string) (map[string]any, error) { + n, err := c.GetNetwork(ctx, id) + if err != nil { + return nil, err + } + c.mu.Lock() + defer c.mu.Unlock() + if entry, ok := c.networks[id]; ok { + return fakeNetworkMap(entry), nil + } + return fakeNetworkMap(&networkEntry{network: n}), nil +} + +func (c *Client) listNetworkItems(tags map[string]string) ([]map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if len(tags) == 0 { + return nil, fmt.Errorf("empty tags: %w", shared.ErrInvalidInput) + } + items := make([]map[string]any, 0, len(c.networks)) + for _, entry := range c.networks { + if shared.MapContains(entry.tags, tags) { + items = append(items, fakeNetworkMap(entry)) + } + } + return items, nil +} + +func (c *Client) createNetwork(name, prefix string, tags map[string]string) (map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextCreateNetwork); err != nil { + return nil, err + } + if name == "" { + return nil, fmt.Errorf("network name is empty: %w", shared.ErrInvalidInput) + } + var prefixes []string + if prefix != "" { + prefixes = []string{prefix} + } + net := &network.Network{ + ID: c.genID(), + Name: name, + IPv4Prefixes: prefixes, + } + entry := &networkEntry{ + network: net, + tags: copyTags(tags), + } + c.networks[net.ID] = entry + return fakeNetworkMap(entry), nil +} + +func (c *Client) deleteNetwork(id string) error { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextDeleteNetwork); err != nil { + return err + } + if _, ok := c.networks[id]; !ok { + return fmt.Errorf("network %q: %w", id, shared.ErrNotFound) + } + delete(c.networks, id) + return nil +} + +func fakeNetworkMap(entry *networkEntry) map[string]any { + m := map[string]any{ + "id": entry.network.ID, + "name": entry.network.Name, + "status": "CREATED", + "routed": true, + } + if len(entry.network.IPv4Prefixes) > 0 { + m["ipv4"] = map[string]any{ + "prefixes": slices.Clone(entry.network.IPv4Prefixes), + } + } + if len(entry.tags) > 0 { + labels := make(map[string]any, len(entry.tags)) + for k, v := range entry.tags { + labels[k] = v + } + m["labels"] = labels + } + return m +} + +func (c *Client) handleAvailabilityZoneRequest(rec *httptest.ResponseRecorder, r *http.Request) bool { + if r.Method != http.MethodGet || !strings.HasSuffix(r.URL.Path, "/availability-zones") { + return false + } + zones, err := c.ListAvailabilityZones(r.Context()) + if err != nil { + writeFakeError(rec, err) + return true + } + _ = json.NewEncoder(rec).Encode(map[string]any{"items": zones}) + return true +} + +func (c *Client) roundTripLB(r *http.Request) (*http.Response, error) { + rec := httptest.NewRecorder() + rec.Header().Set("Content-Type", "application/json") + + if c.handleLoadBalancerRequest(rec, r) { + return rec.Result(), nil + } + + rec.WriteHeader(http.StatusNotFound) + _ = json.NewEncoder(rec).Encode(map[string]any{"message": "not found"}) + return rec.Result(), nil +} + +type fakeTargetJSON struct { + DisplayName string `json:"displayName"` + IP string `json:"ip"` +} + +func toLoadBalancerTargets(in []fakeTargetJSON) []loadbalancer.Target { + out := make([]loadbalancer.Target, 0, len(in)) + for _, t := range in { + out = append(out, loadbalancer.Target{Name: t.DisplayName, IP: t.IP}) + } + return out +} + +func (c *Client) handleLoadBalancerRequest(rec *httptest.ResponseRecorder, r *http.Request) bool { + path := r.URL.Path + + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers"): + items, err := c.listLoadBalancerItems() + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(map[string]any{"loadBalancers": items}) + } + return true + + case r.Method == http.MethodPost && strings.HasSuffix(path, "/load-balancers"): + var body struct { + Name string `json:"name"` + Labels map[string]string `json:"labels"` + TargetPools []struct { + Name string `json:"name"` + TargetPort int32 `json:"targetPort"` + Targets []fakeTargetJSON `json:"targets"` + } `json:"targetPools"` + Listeners []struct { + Port int32 `json:"port"` + } `json:"listeners"` + } + if r.Body != nil { + _ = json.NewDecoder(r.Body).Decode(&body) + } + var port int32 = 6443 + if len(body.Listeners) > 0 && body.Listeners[0].Port > 0 { + port = body.Listeners[0].Port + } + var targets []loadbalancer.Target + if len(body.TargetPools) > 0 { + targets = toLoadBalancerTargets(body.TargetPools[0].Targets) + } + created, err := c.createLoadBalancer(body.Name, port, body.Labels, targets) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(created) + } + return true + + case r.Method == http.MethodPut && strings.Contains(path, "/load-balancers/") && strings.Contains(path, "/target-pools/"): + sub := path[strings.Index(path, "/load-balancers/")+len("/load-balancers/"):] + parts := strings.SplitN(sub, "/target-pools/", 2) + lbID := parts[0] + var body struct { + Name string `json:"name"` + TargetPort int32 `json:"targetPort"` + Targets []fakeTargetJSON `json:"targets"` + } + if r.Body != nil { + _ = json.NewDecoder(r.Body).Decode(&body) + } + pool, err := c.updateLoadBalancerTargetPool(lbID, body.TargetPort, toLoadBalancerTargets(body.Targets)) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(pool) + } + return true + + case r.Method == http.MethodGet && strings.Contains(path, "/load-balancers/"): + id := path[strings.LastIndex(path, "/load-balancers/")+len("/load-balancers/"):] + got, err := c.getLoadBalancerItem(id) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(got) + } + return true + + case r.Method == http.MethodDelete && strings.Contains(path, "/load-balancers/"): + id := path[strings.LastIndex(path, "/load-balancers/")+len("/load-balancers/"):] + if err := c.deleteLoadBalancer(id); err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(map[string]any{}) + } + return true + + default: + return false + } +} + +func (c *Client) listLoadBalancerItems() ([]map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + items := make([]map[string]any, 0, len(c.loadBalancers)) + for _, entry := range c.loadBalancers { + items = append(items, fakeLoadBalancerMap(entry)) + } + return items, nil } -func (c *Client) publicIPByTags(tags map[string]string) *cloud.PublicIP { +func (c *Client) getLoadBalancerItem(id string) (map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + entry, ok := c.loadBalancers[id] + if !ok { + return nil, fmt.Errorf("load balancer %q: %w", id, shared.ErrNotFound) + } + item := fakeLoadBalancerMap(entry) + // Force SetTargets to see a target diff and issue UpdateTargetPool so + // FailNextSetTargets is consumed on the target update call rather than Get. + if c.FailNextSetTargets != nil { + bootstrap := loadbalancer.BootstrapTarget("") + item["targetPools"] = []any{ + map[string]any{ + "name": "apiserver", + "targetPort": entry.lb.Port, + "targets": []any{ + map[string]any{ + "displayName": bootstrap.Name, + "ip": bootstrap.IP, + }, + }, + }, + } + } + return item, nil +} + +func (c *Client) createLoadBalancer(name string, port int32, labels map[string]string, targets []loadbalancer.Target) (map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextEnsureLB); err != nil { + return nil, err + } + entry, err := c.createLoadBalancerEntry(name, port, labels, targets) + if err != nil { + return nil, err + } + return fakeLoadBalancerMap(entry), nil +} + +func (c *Client) createLoadBalancerEntry(name string, port int32, labels map[string]string, targets []loadbalancer.Target) (*lbEntry, error) { + if name == "" { + return nil, fmt.Errorf("load balancer name is empty: %w", shared.ErrInvalidInput) + } + if port <= 0 { + port = 6443 + } + lbObj := &loadbalancer.LoadBalancer{ + ID: name, + Name: name, + IP: "203.0.113.10", + Port: port, + } + targetMap := map[string]string{} + if len(targets) == 0 { + bootstrap := loadbalancer.BootstrapTarget("") + targetMap[bootstrap.Name] = bootstrap.IP + } else { + for _, target := range targets { + targetMap[target.Name] = target.IP + } + } + entry := &lbEntry{ + lb: lbObj, + tags: copyTags(labels), + targets: targetMap, + } + c.loadBalancers[name] = entry + return entry, nil +} + +func (c *Client) updateLoadBalancerTargetPool(id string, port int32, targets []loadbalancer.Target) (map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextSetTargets); err != nil { + return nil, err + } + if id == "" || port <= 0 { + return nil, fmt.Errorf("load balancer ID and target port are required: %w", shared.ErrInvalidInput) + } + if len(targets) == 0 { + return nil, fmt.Errorf("at least one target is required: %w", shared.ErrInvalidInput) + } + entry, ok := c.loadBalancers[id] + if !ok { + return nil, fmt.Errorf("load balancer %q: %w", id, shared.ErrNotFound) + } + replaced := make(map[string]string, len(targets)) + for _, target := range targets { + if target.Name == "" || target.IP == "" { + return nil, fmt.Errorf("target name and target IP are required: %w", shared.ErrInvalidInput) + } + replaced[target.Name] = target.IP + } + entry.targets = replaced + entry.lb.Port = port + return fakeTargetPoolMap(entry), nil +} + +func (c *Client) deleteLoadBalancer(id string) error { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextDeleteLB); err != nil { + return err + } + delete(c.loadBalancers, id) + return nil +} + +func fakeLoadBalancerMap(entry *lbEntry) map[string]any { + m := map[string]any{ + "name": entry.lb.Name, + "externalAddress": entry.lb.IP, + "listeners": []any{ + map[string]any{ + "displayName": "apiserver", + "port": entry.lb.Port, + "targetPool": "apiserver", + }, + }, + "targetPools": []any{ + fakeTargetPoolMap(entry), + }, + } + if len(entry.tags) > 0 { + labels := make(map[string]any, len(entry.tags)) + for k, v := range entry.tags { + labels[k] = v + } + m["labels"] = labels + } + return m +} + +func fakeTargetPoolMap(entry *lbEntry) map[string]any { + targets := make([]any, 0, len(entry.targets)) + for name, ip := range entry.targets { + targets = append(targets, map[string]any{ + "displayName": name, + "ip": ip, + }) + } + return map[string]any{ + "name": "apiserver", + "targetPort": entry.lb.Port, + "targets": targets, + } +} + +func (c *Client) handlePublicIPRequest(rec *httptest.ResponseRecorder, r *http.Request) bool { + path := r.URL.Path + + switch { + case strings.Contains(path, "/servers/") && strings.Contains(path, "/public-ips/"): + parts := strings.Split(path, "/servers/") + sub := strings.Split(parts[1], "/public-ips/") + serverID, publicIPID := sub[0], sub[1] + var err error + switch r.Method { + case http.MethodPut: + err = c.addPublicIPToServer(r.Context(), serverID, publicIPID) + case http.MethodDelete: + err = c.removePublicIPFromServer(r.Context(), serverID, publicIPID) + default: + err = shared.ErrInvalidInput + } + writeFakeStatus(rec, err) + return true + + case r.Method == http.MethodPost && strings.HasSuffix(path, "/public-ips"): + var body struct { + Labels map[string]string `json:"labels"` + } + if r.Body != nil { + _ = json.NewDecoder(r.Body).Decode(&body) + } + created, err := c.createPublicIP(r.Context(), body.Labels) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(fakePublicIPMap(created, body.Labels)) + } + return true + + case r.Method == http.MethodGet && strings.HasSuffix(path, "/public-ips"): + tags := parseLabelSelector(r.URL.Query().Get("label_selector")) + items, err := c.listPublicIPItems(tags) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(map[string]any{"items": items}) + } + return true + + case r.Method == http.MethodGet && strings.Contains(path, "/public-ips/"): + id := path[strings.LastIndex(path, "/public-ips/")+len("/public-ips/"):] + got, err := c.getPublicIP(r.Context(), id) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(fakePublicIPMap(got, nil)) + } + return true + + case r.Method == http.MethodDelete && strings.Contains(path, "/public-ips/"): + id := path[strings.LastIndex(path, "/public-ips/")+len("/public-ips/"):] + writeFakeStatus(rec, c.deletePublicIP(r.Context(), id)) + return true + + default: + return false + } +} + +func (c *Client) handleSecurityGroupRequest(rec *httptest.ResponseRecorder, r *http.Request) bool { + path := r.URL.Path + + switch { + case strings.Contains(path, "/servers/") && strings.Contains(path, "/security-groups/"): + parts := strings.Split(path, "/servers/") + sub := strings.Split(parts[1], "/security-groups/") + serverID, securityGroupID := sub[0], sub[1] + var err error + switch r.Method { + case http.MethodPut: + err = c.addSecurityGroupToServer(serverID, securityGroupID) + case http.MethodDelete: + err = c.removeSecurityGroupFromServer(serverID, securityGroupID) + default: + err = shared.ErrInvalidInput + } + writeFakeStatus(rec, err) + return true + + case r.Method == http.MethodPost && strings.HasSuffix(path, "/security-groups"): + var body struct { + Name string `json:"name"` + Description string `json:"description"` + Labels map[string]string `json:"labels"` + } + if r.Body != nil { + _ = json.NewDecoder(r.Body).Decode(&body) + } + created, err := c.createSecurityGroup(body.Name, body.Description, body.Labels) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(created) + } + return true + + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + tags := parseLabelSelector(r.URL.Query().Get("label_selector")) + items, err := c.listSecurityGroupItems(tags) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(map[string]any{"items": items}) + } + return true + + case strings.Contains(path, "/security-groups/") && strings.HasSuffix(path, "/rules") && r.Method == http.MethodGet: + sub := path[strings.Index(path, "/security-groups/")+len("/security-groups/"):] + sgID := strings.TrimSuffix(sub, "/rules") + items, err := c.listSecurityGroupRuleItems(sgID) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(map[string]any{"items": items}) + } + return true + + case strings.Contains(path, "/security-groups/") && strings.HasSuffix(path, "/rules") && r.Method == http.MethodPost: + c.handleCreateSecurityGroupRule(rec, r) + return true + + case strings.Contains(path, "/security-groups/") && strings.Contains(path, "/rules/") && r.Method == http.MethodDelete: + sub := path[strings.Index(path, "/security-groups/")+len("/security-groups/"):] + parts := strings.SplitN(sub, "/rules/", 2) + writeFakeStatus(rec, c.deleteSecurityGroupRule(parts[0], parts[1])) + return true + + case r.Method == http.MethodGet && strings.Contains(path, "/security-groups/"): + id := path[strings.LastIndex(path, "/security-groups/")+len("/security-groups/"):] + got, err := c.getSecurityGroupItem(id) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(got) + } + return true + + case r.Method == http.MethodDelete && strings.Contains(path, "/security-groups/"): + id := path[strings.LastIndex(path, "/security-groups/")+len("/security-groups/"):] + writeFakeStatus(rec, c.deleteSecurityGroup(id)) + return true + + default: + return false + } +} + +func (c *Client) handleCreateSecurityGroupRule(rec *httptest.ResponseRecorder, r *http.Request) { + path := r.URL.Path + sub := path[strings.Index(path, "/security-groups/")+len("/security-groups/"):] + sgID := strings.TrimSuffix(sub, "/rules") + var body struct { + Direction string `json:"direction"` + Protocol string `json:"protocol"` + PortRange *struct { + Min int64 `json:"min"` + Max int64 `json:"max"` + } `json:"portRange"` + IPRange string `json:"ipRange"` + RemoteSecurityGroupID string `json:"remoteSecurityGroupId"` + } + if r.Body != nil { + _ = json.NewDecoder(r.Body).Decode(&body) + } + var portMin, portMax int64 + if body.PortRange != nil { + portMin = body.PortRange.Min + portMax = body.PortRange.Max + } + created, err := c.createSecurityGroupRule(sgID, securityGroupRuleEntry{ + Rule: securitygroup.Rule{ + Direction: securitygroup.Direction(body.Direction), + Protocol: securitygroup.Protocol(body.Protocol), + PortMin: portMin, + PortMax: portMax, + IPRange: body.IPRange, + RemoteSecurityGroupID: body.RemoteSecurityGroupID, + }, + }) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(created) + } +} + +func writeFakeStatus(rec *httptest.ResponseRecorder, err error) { + if err != nil { + writeFakeError(rec, err) + } else { + rec.WriteHeader(http.StatusNoContent) + } +} + +func (c *Client) listPublicIPItems(tags map[string]string) ([]map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextListPublicIPs); err != nil { + return nil, err + } + if len(tags) == 0 { + return nil, fmt.Errorf("empty tags: %w", shared.ErrInvalidInput) + } + items := make([]map[string]any, 0, len(c.publicIPs)) for _, entry := range c.publicIPs { - if mapContains(entry.tags, tags) { - out := *entry.publicIP - return &out + if shared.MapContains(entry.tags, tags) { + items = append(items, fakePublicIPMap(entry.publicIP, entry.tags)) } } + return items, nil +} + +func fakePublicIPMap(p *publicip.PublicIP, tags map[string]string) map[string]any { + m := map[string]any{ + "id": p.ID, + "ip": p.IP, + } + if p.NetworkInterfaceID != "" { + m["networkInterface"] = p.NetworkInterfaceID + } + if len(tags) > 0 { + labels := make(map[string]any, len(tags)) + for k, v := range tags { + labels[k] = v + } + m["labels"] = labels + } + return m +} + +func (c *Client) addSecurityGroupToServer(serverID, securityGroupID string) error { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextAddSecurityGroup); err != nil { + return err + } + serverEntry, ok := c.servers[serverID] + if !ok { + return fmt.Errorf("server %q: %w", serverID, shared.ErrNotFound) + } + if _, ok := c.securityGroups[securityGroupID]; !ok { + return fmt.Errorf("security group %q: %w", securityGroupID, shared.ErrNotFound) + } + if serverEntry.securityGroups == nil { + serverEntry.securityGroups = map[string]struct{}{} + } + serverEntry.securityGroups[securityGroupID] = struct{}{} + c.AddSecurityGroupCalls++ return nil } -func (c *Client) securityGroupByTags(tags map[string]string) *cloud.SecurityGroup { - for _, entry := range c.securityGroups { - if mapContains(entry.tags, tags) { - out := *entry.securityGroup - return &out +func (c *Client) handleServerRequest(rec *httptest.ResponseRecorder, r *http.Request) bool { + path := r.URL.Path + + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/servers"): + tags := parseLabelSelector(r.URL.Query().Get("label_selector")) + items, err := c.listServerItems(tags) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(map[string]any{"items": items}) + } + return true + + case r.Method == http.MethodPost && strings.HasSuffix(path, "/servers"): + c.handleCreateServer(rec, r) + return true + + case r.Method == http.MethodGet && strings.Contains(path, "/servers/") && strings.HasSuffix(path, "/nics"): + sub := path[strings.Index(path, "/servers/")+len("/servers/"):] + serverID := strings.TrimSuffix(sub, "/nics") + items, err := c.listServerNICItems(serverID) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(map[string]any{"items": items}) + } + return true + + case r.Method == http.MethodGet && strings.Contains(path, "/servers/"): + serverID := path[strings.LastIndex(path, "/servers/")+len("/servers/"):] + item, err := c.getServerItem(serverID) + if err != nil { + writeFakeError(rec, err) + } else { + _ = json.NewEncoder(rec).Encode(item) + } + return true + + case r.Method == http.MethodDelete && strings.Contains(path, "/servers/"): + serverID := path[strings.LastIndex(path, "/servers/")+len("/servers/"):] + writeFakeStatus(rec, c.deleteServerHTTP(serverID)) + return true + + default: + return false + } +} + +func (c *Client) deleteServerHTTP(id string) error { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextDeleteServer); err != nil { + return err + } + if _, ok := c.servers[id]; !ok { + return fmt.Errorf("server %q: %w", id, shared.ErrNotFound) + } + for _, entry := range c.publicIPs { + if entry.publicIP.NetworkInterfaceID == "fake-nic-"+id { + entry.publicIP.NetworkInterfaceID = "" } } + delete(c.servers, id) return nil } -func idOfPublicIP(publicIP *cloud.PublicIP) string { - if publicIP == nil { - return "" +func (c *Client) handleCreateServer(rec *httptest.ResponseRecorder, r *http.Request) { + var body struct { + Name string `json:"name"` + MachineType string `json:"machineType"` + ImageID string `json:"imageId"` + AvailabilityZone string `json:"availabilityZone"` + KeypairName string `json:"keypairName"` + SecurityGroups []string `json:"securityGroups"` + UserData string `json:"userData"` + Labels map[string]string `json:"labels"` + Networking *struct { + NetworkID string `json:"networkId"` + } `json:"networking"` + BootVolume *struct { + Size int `json:"size"` + PerformanceClass string `json:"performanceClass"` + DeleteOnTermination bool `json:"deleteOnTermination"` + Source *struct { + ID string `json:"id"` + } `json:"source"` + } `json:"bootVolume"` + } + if r.Body != nil { + _ = json.NewDecoder(r.Body).Decode(&body) + } + var userData []byte + if body.UserData != "" { + userData, _ = base64.StdEncoding.DecodeString(body.UserData) + } + var networkID string + if body.Networking != nil { + networkID = body.Networking.NetworkID + } + imageID := body.ImageID + var rootVolume server.RootVolume + if body.BootVolume != nil { + rootVolume = server.RootVolume{ + SizeGiB: body.BootVolume.Size, + PerformanceClass: body.BootVolume.PerformanceClass, + DeleteOnTermination: body.BootVolume.DeleteOnTermination, + } + if imageID == "" && body.BootVolume.Source != nil { + imageID = body.BootVolume.Source.ID + } + } + spec := server.ServerSpec{ + Name: body.Name, + MachineType: body.MachineType, + ImageID: imageID, + AvailabilityZone: body.AvailabilityZone, + SSHKeyName: body.KeypairName, + NetworkID: networkID, + SecurityGroups: body.SecurityGroups, + UserData: userData, + Tags: body.Labels, + RootVolume: rootVolume, + } + + c.mu.Lock() + if c.BeforeCreateServer != nil { + c.mu.Unlock() + c.BeforeCreateServer() + c.mu.Lock() + } + if err := consume(&c.FailNextCreateServer); err != nil { + c.mu.Unlock() + writeFakeError(rec, err) + return } - return publicIP.ID + entry := c.createServerEntry(spec) + item := fakeServerMap(entry) + c.mu.Unlock() + + _ = json.NewEncoder(rec).Encode(item) } -func ipOfPublicIP(publicIP *cloud.PublicIP) string { - if publicIP == nil { - return "" +func (c *Client) getServerItem(id string) (map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if err := consume(&c.FailNextGetServer); err != nil { + return nil, err } - return publicIP.IP + entry, ok := c.servers[id] + if !ok { + return nil, fmt.Errorf("server %q: %w", id, shared.ErrNotFound) + } + return fakeServerMap(entry), nil } -func idOfSecurityGroup(securityGroup *cloud.SecurityGroup) string { - if securityGroup == nil { - return "" +func (c *Client) listServerNICItems(serverID string) ([]map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + entry, ok := c.servers[serverID] + if !ok { + return nil, fmt.Errorf("server %q: %w", serverID, shared.ErrNotFound) } - return securityGroup.ID + items := make([]map[string]any, 0, len(entry.server.Addresses)) + for _, addr := range entry.server.Addresses { + items = append(items, map[string]any{"ipv4": addr.Address}) + } + return items, nil } -func (c *Client) ListAvailabilityZones(_ context.Context) ([]string, error) { +func (c *Client) listServerItems(tags map[string]string) ([]map[string]any, error) { c.mu.Lock() defer c.mu.Unlock() - if err := consume(&c.FailNextListAZ); err != nil { + + if err := consume(&c.FailNextFindServer); err != nil { return nil, err } - if len(c.AvailabilityZones) > 0 { - return slices.Clone(c.AvailabilityZones), nil + items := make([]map[string]any, 0, len(c.servers)) + for _, entry := range c.servers { + if len(tags) > 0 && !shared.MapContains(entry.tags, tags) { + continue + } + items = append(items, fakeServerMap(entry)) } - return []string{"eu01-1", "eu01-2", "eu01-3"}, nil + return items, nil +} + +func fakeServerMap(entry *serverEntry) map[string]any { + m := map[string]any{ + "id": entry.server.ID, + "name": entry.server.Name, + "machineType": "c2i.1", + "status": entry.server.State, + "availabilityZone": entry.server.AvailabilityZone, + } + if entry.server.PowerStatus != "" { + m["powerStatus"] = entry.server.PowerStatus + } + if len(entry.tags) > 0 { + labels := make(map[string]any, len(entry.tags)) + for k, v := range entry.tags { + labels[k] = v + } + m["labels"] = labels + } + return m +} + +func (c *Client) removeSecurityGroupFromServer(serverID, securityGroupID string) error { + c.mu.Lock() + defer c.mu.Unlock() + + serverEntry, ok := c.servers[serverID] + if !ok { + return fmt.Errorf("server %q: %w", serverID, shared.ErrNotFound) + } + delete(serverEntry.securityGroups, securityGroupID) + return nil +} + +func (c *Client) createSecurityGroup(name, description string, tags map[string]string) (map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + entry, err := c.createSecurityGroupEntry(name, description, tags) + if err != nil { + return nil, err + } + return fakeSecurityGroupMap(entry), nil +} + +func (c *Client) createSecurityGroupEntry(name, description string, tags map[string]string) (*securityGroupEntry, error) { + if name == "" { + return nil, fmt.Errorf("security group name is empty: %w", shared.ErrInvalidInput) + } + id := c.genID() + sg := &securitygroup.SecurityGroup{ + ID: id, + Name: name, + } + entry := &securityGroupEntry{ + securityGroup: sg, + description: description, + tags: copyTags(tags), + rules: make(map[string]*securityGroupRuleEntry), + } + c.securityGroups[id] = entry + return entry, nil +} + +func (c *Client) getSecurityGroupItem(id string) (map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if id == "" { + return nil, fmt.Errorf("security group ID is empty: %w", shared.ErrInvalidInput) + } + entry, ok := c.securityGroups[id] + if !ok { + return nil, fmt.Errorf("security group %q: %w", id, shared.ErrNotFound) + } + return fakeSecurityGroupMap(entry), nil +} + +func (c *Client) listSecurityGroupItems(tags map[string]string) ([]map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + if len(tags) == 0 { + return nil, fmt.Errorf("empty tags: %w", shared.ErrInvalidInput) + } + items := make([]map[string]any, 0, len(c.securityGroups)) + for _, entry := range c.securityGroups { + if shared.MapContains(entry.tags, tags) { + items = append(items, fakeSecurityGroupMap(entry)) + } + } + return items, nil +} + +func (c *Client) listSecurityGroupRuleItems(sgID string) ([]map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + entry, ok := c.securityGroups[sgID] + if !ok { + return nil, fmt.Errorf("security group %q: %w", sgID, shared.ErrNotFound) + } + items := make([]map[string]any, 0, len(entry.rules)) + for _, rule := range entry.rules { + items = append(items, fakeSecurityGroupRuleMap(rule)) + } + return items, nil +} + +func (c *Client) createSecurityGroupRule(sgID string, rule securityGroupRuleEntry) (map[string]any, error) { + c.mu.Lock() + defer c.mu.Unlock() + + entry, ok := c.securityGroups[sgID] + if !ok { + return nil, fmt.Errorf("security group %q: %w", sgID, shared.ErrNotFound) + } + if entry.rules == nil { + entry.rules = make(map[string]*securityGroupRuleEntry) + } + rule.id = c.genID() + stored := rule + entry.rules[rule.id] = &stored + return fakeSecurityGroupRuleMap(&stored), nil +} + +func (c *Client) deleteSecurityGroupRule(sgID, ruleID string) error { + c.mu.Lock() + defer c.mu.Unlock() + + entry, ok := c.securityGroups[sgID] + if !ok { + return fmt.Errorf("security group %q: %w", sgID, shared.ErrNotFound) + } + if entry.rules == nil { + return fmt.Errorf("rule %q: %w", ruleID, shared.ErrNotFound) + } + if _, ok := entry.rules[ruleID]; !ok { + return fmt.Errorf("rule %q: %w", ruleID, shared.ErrNotFound) + } + delete(entry.rules, ruleID) + return nil } -func cloneServer(s *cloud.Server) *cloud.Server { - out := *s - if s.Addresses != nil { - out.Addresses = make([]cloud.Address, len(s.Addresses)) - copy(out.Addresses, s.Addresses) +func (c *Client) deleteSecurityGroup(id string) error { + c.mu.Lock() + defer c.mu.Unlock() + + if id == "" { + return fmt.Errorf("security group ID is empty: %w", shared.ErrInvalidInput) + } + if _, ok := c.securityGroups[id]; !ok { + return fmt.Errorf("security group %q: %w", id, shared.ErrNotFound) + } + for serverID, srv := range c.servers { + if _, attached := srv.securityGroups[id]; attached { + return fmt.Errorf("security group %q is still attached to server %q: %w", id, serverID, shared.ErrConflict) + } + } + delete(c.securityGroups, id) + return nil +} + +func fakeSecurityGroupMap(entry *securityGroupEntry) map[string]any { + m := map[string]any{ + "id": entry.securityGroup.ID, + "name": entry.securityGroup.Name, + } + if entry.description != "" { + m["description"] = entry.description + } + if len(entry.tags) > 0 { + labels := make(map[string]any, len(entry.tags)) + for k, v := range entry.tags { + labels[k] = v + } + m["labels"] = labels + } + return m +} + +func fakeSecurityGroupRuleMap(rule *securityGroupRuleEntry) map[string]any { + m := map[string]any{ + "id": rule.id, + "direction": string(rule.Direction), + } + if rule.Protocol != "" { + m["protocol"] = map[string]any{"name": string(rule.Protocol)} + } + if rule.PortMin > 0 || rule.PortMax > 0 { + m["portRange"] = map[string]any{"min": rule.PortMin, "max": rule.PortMax} + } + if rule.IPRange != "" { + m["ipRange"] = rule.IPRange + } + if rule.RemoteSecurityGroupID != "" { + m["remoteSecurityGroupId"] = rule.RemoteSecurityGroupID + } + return m +} + +func parseLabelSelector(selector string) map[string]string { + if selector == "" { + return nil } - return &out + tags := make(map[string]string) + for part := range strings.SplitSeq(selector, ",") { + if k, v, ok := strings.Cut(part, "="); ok && k != "" { + tags[k] = v + } + } + return tags +} + +func writeFakeError(rec *httptest.ResponseRecorder, err error) { + status := http.StatusInternalServerError + switch { + case shared.IsNotFound(err): + status = http.StatusNotFound + case shared.IsConflict(err): + status = http.StatusConflict + case shared.IsInvalidInput(err): + status = http.StatusBadRequest + case shared.IsUnauthorized(err): + status = http.StatusUnauthorized + } + rec.WriteHeader(status) + _ = json.NewEncoder(rec).Encode(map[string]any{"message": err.Error()}) } diff --git a/cloud/providerid.go b/cloud/providerid.go deleted file mode 100644 index 61c7307..0000000 --- a/cloud/providerid.go +++ /dev/null @@ -1,53 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package cloud - -import ( - "errors" - "fmt" - "strings" -) - -// providerIDScheme is the URL scheme used for STACKIT providerIDs. -const providerIDScheme = "stackit://" - -// ErrInvalidProviderID is returned by ParseProviderID for malformed values. -var ErrInvalidProviderID = errors.New("invalid providerID") - -// NewProviderID returns a providerID string in the STACKIT format used by -// cloud-provider-stackit. -// -// Format verified against the local cloud-provider-stackit repository: -// - pkg/ccm/instances.go: Instances.makeInstanceID returns stackit:// -// - pkg/ccm/instances.go: instanceIDFromProviderID parses only the server ID -// -// Project ID and region are intentionally not encoded in the providerID. The -// cloud-provider-stackit controller gets project and region from its own -// configuration and then resolves Node.spec.providerID via GetServer(projectID, -// region, serverID). -func NewProviderID(projectID, region, serverID string) string { - return fmt.Sprintf("%s%s", providerIDScheme, serverID) -} - -// ParseProviderID splits a providerID string into its components. The current -// STACKIT providerID format does not contain project or region, so those return -// values are empty. It returns ErrInvalidProviderID if any encoded component is -// empty or the scheme is wrong. -func ParseProviderID(providerID string) (projectID, region, serverID string, err error) { - if !strings.HasPrefix(providerID, providerIDScheme) { - return "", "", "", fmt.Errorf("%w: missing scheme %q", ErrInvalidProviderID, providerIDScheme) - } - serverID = strings.TrimPrefix(providerID, providerIDScheme) - if serverID == "" || strings.Contains(serverID, "/") { - return "", "", "", fmt.Errorf("%w: expected , got %q", ErrInvalidProviderID, serverID) - } - return "", "", serverID, nil -} diff --git a/cloud/providerid_test.go b/cloud/providerid_test.go deleted file mode 100644 index 452305e..0000000 --- a/cloud/providerid_test.go +++ /dev/null @@ -1,93 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package cloud - -import ( - "errors" - "testing" -) - -func TestNewProviderID(t *testing.T) { - got := NewProviderID("project-id", "eu01", "server-id") - want := "stackit://server-id" - if got != want { - t.Fatalf("NewProviderID() = %q, want %q", got, want) - } -} - -func TestParseProviderID(t *testing.T) { - projectID, region, serverID, err := ParseProviderID("stackit://server-id") - if err != nil { - t.Fatalf("ParseProviderID() error = %v", err) - } - if projectID != "" || region != "" || serverID != "server-id" { - t.Fatalf("ParseProviderID() = %q, %q, %q", projectID, region, serverID) - } -} - -func TestParseProviderIDInvalid(t *testing.T) { - tests := []string{ - "", - "aws://server-id", - "stackit://project-id/server-id", - "stackit:///server-id", - "stackit://server-id/extra", - "stackit://", - } - - for _, tt := range tests { - t.Run(tt, func(t *testing.T) { - _, _, _, err := ParseProviderID(tt) - if !errors.Is(err, ErrInvalidProviderID) { - t.Fatalf("ParseProviderID(%q) error = %v, want ErrInvalidProviderID", tt, err) - } - }) - } -} - -func TestProviderIDRoundTrip(t *testing.T) { - wantProjectID, wantRegion, wantServerID := "project-id", "eu01", "server-id" - - gotProjectID, gotRegion, gotServerID, err := ParseProviderID(NewProviderID(wantProjectID, wantRegion, wantServerID)) - if err != nil { - t.Fatalf("ParseProviderID(NewProviderID()) error = %v", err) - } - if gotProjectID != "" || gotRegion != "" || gotServerID != wantServerID { - t.Fatalf("roundtrip = %q, %q, %q", gotProjectID, gotRegion, gotServerID) - } -} - -func TestProviderIDMatchesCloudProviderStackitFormat(t *testing.T) { - serverID := "321a8b81-3660-43e5-bab8-6470b65ee4e8" - providerID := NewProviderID("project-id", "eu01", serverID) - - // Verified against the local cloud-provider-stackit repository: - // pkg/ccm/instances.go uses fmt.Sprintf("%s://%s", ProviderName, server.GetId()). - if providerID != "stackit://"+serverID { - t.Fatalf("NewProviderID() = %q, want cloud-provider-stackit format %q", providerID, "stackit://"+serverID) - } - - projectID, region, parsedServerID, err := ParseProviderID(providerID) - if err != nil { - t.Fatalf("ParseProviderID(%q) error = %v", providerID, err) - } - if projectID != "" || region != "" { - t.Fatalf( - "ParseProviderID(%q) returned project/region %q/%q, want empty because cloud-provider-stackit does not encode them", - providerID, - projectID, - region, - ) - } - if parsedServerID != serverID { - t.Fatalf("ParseProviderID(%q) serverID = %q, want %q", providerID, parsedServerID, serverID) - } -} diff --git a/cloud/sdk_client.go b/cloud/sdk_client.go index bf3a17c..45a06e2 100644 --- a/cloud/sdk_client.go +++ b/cloud/sdk_client.go @@ -11,18 +11,12 @@ You may obtain a copy of the License at package cloud import ( - "cmp" "context" - "encoding/base64" - "errors" "fmt" - "net/http" "os" - "slices" - "strings" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" "github.com/stackitcloud/stackit-sdk-go/core/config" - "github.com/stackitcloud/stackit-sdk-go/core/oapierror" iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" lb "github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/v2api" ) @@ -32,13 +26,6 @@ const ( stackitTokenEndpointEnv = "STACKIT_TOKEN_BASEURL" stackitIAASEndpointEnv = "STACKIT_IAAS_ENDPOINT" stackitLBEndpointEnv = "STACKIT_LOADBALANCER_ENDPOINT" - - apiserverTargetPoolName = "apiserver" - apiserverListenerName = "apiserver" - bootstrapTargetName = "capi-bootstrap-placeholder" - bootstrapTargetIP = "10.0.0.1" - sshPort = 22 - tcpProtocol = "tcp" ) // SDKClient is the STACKIT SDK-backed implementation of Client. @@ -57,22 +44,22 @@ type SDKClient struct { // service-account key flow. func NewClient(_ context.Context, creds Credentials) (Client, error) { if creds.ProjectID == "" { - return nil, fmt.Errorf("%w: project ID is empty", ErrInvalidInput) + return nil, fmt.Errorf("%w: project ID is empty", shared.ErrInvalidInput) } if creds.Region == "" { - return nil, fmt.Errorf("%w: region is empty", ErrInvalidInput) + return nil, fmt.Errorf("%w: region is empty", shared.ErrInvalidInput) } if len(creds.ServiceAccountJSON) == 0 && os.Getenv(stackitNoAuthEnv) != "true" { - return nil, fmt.Errorf("%w: service account JSON is empty", ErrInvalidInput) + return nil, fmt.Errorf("%w: service account JSON is empty", shared.ErrInvalidInput) } iaasClient, err := iaas.NewAPIClient(stackitOptions(creds, os.Getenv(stackitIAASEndpointEnv))...) if err != nil { - return nil, fmt.Errorf("%w: create IAAS SDK client: %v", ErrInvalidInput, err) + return nil, fmt.Errorf("%w: create IAAS SDK client: %v", shared.ErrInvalidInput, err) } lbClient, err := lb.NewAPIClient(stackitOptions(creds, os.Getenv(stackitLBEndpointEnv))...) if err != nil { - return nil, fmt.Errorf("%w: create load balancer SDK client: %v", ErrInvalidInput, err) + return nil, fmt.Errorf("%w: create load balancer SDK client: %v", shared.ErrInvalidInput, err) } return &SDKClient{ @@ -83,6 +70,22 @@ func NewClient(_ context.Context, creds Credentials) (Client, error) { }, nil } +func (c *SDKClient) ProjectID() string { + return c.projectID +} + +func (c *SDKClient) Region() string { + return c.region +} + +func (c *SDKClient) IaaSClient() *iaas.APIClient { + return c.iaasClient +} + +func (c *SDKClient) LoadBalancerClient() *lb.APIClient { + return c.lbClient +} + func stackitOptions(creds Credentials, endpoint string) []config.ConfigurationOption { opts := []config.ConfigurationOption{ config.WithUserAgent("cluster-api-provider-stackit"), @@ -100,1104 +103,3 @@ func stackitOptions(creds Credentials, endpoint string) []config.ConfigurationOp } return opts } - -func (c *SDKClient) GetServer(ctx context.Context, id string) (*Server, error) { - server, err := c.iaasClient.DefaultAPI.GetServer(ctx, c.projectID, c.region, id).Execute() - if err != nil { - return nil, classifySDKError("get server", err) - } - return c.serverFromSDK(ctx, server), nil -} - -func (c *SDKClient) FindServerByTags(ctx context.Context, tags map[string]string) (*Server, error) { - servers, err := c.ListServersByTags(ctx, tags) - if err != nil { - return nil, err - } - if len(servers) == 0 { - return nil, fmt.Errorf("%w: no server matching tags", ErrNotFound) - } - if len(servers) > 1 { - return nil, fmt.Errorf("%w: multiple servers matching tags", ErrConflict) - } - return servers[0], nil -} - -func (c *SDKClient) ListServersByTags(ctx context.Context, tags map[string]string) ([]*Server, error) { - if len(tags) == 0 { - return nil, fmt.Errorf("%w: empty tag selector", ErrInvalidInput) - } - resp, err := c.iaasClient.DefaultAPI.ListServers(ctx, c.projectID, c.region). - LabelSelector(labelSelector(tags)). - Details(true). - Execute() - if err != nil { - return nil, classifySDKError("list servers", err) - } - matched := []*Server{} - for _, server := range resp.GetItems() { - if labelsContainTags(server.GetLabels(), tags) { - server := server - matched = append(matched, c.serverFromSDK(ctx, &server)) - } - } - return matched, nil -} - -func (c *SDKClient) CreateServer(ctx context.Context, input CreateServerInput) (*Server, error) { - if existing, err := c.FindServerByTags(ctx, input.Tags); err == nil { - return existing, nil - } else if !IsNotFound(err) { - return nil, err - } - - payload := &iaas.CreateServerPayload{} - payload.SetName(input.Name) - payload.SetMachineType(input.MachineType) - useBootVolume := input.RootVolume.SizeGiB > 0 || input.RootVolume.PerformanceClass != "" - if input.ImageID != "" && !useBootVolume { - payload.SetImageId(input.ImageID) - } - if len(input.Tags) > 0 { - payload.SetLabels(tagsToSDKLabels(input.Tags)) - } - networking := iaas.NewCreateServerNetworking() - if input.NetworkID != "" { - networking.SetNetworkId(input.NetworkID) - } - payload.SetNetworking(iaas.CreateServerNetworkingAsCreateServerPayloadAllOfNetworking(networking)) - if len(input.SecurityGroups) > 0 { - payload.SetSecurityGroups(input.SecurityGroups) - } - if len(input.UserData) > 0 { - payload.SetUserData(base64.StdEncoding.EncodeToString(input.UserData)) - payload.SetConfigDrive(true) - } - if useBootVolume { - bootVolume := iaas.NewBootVolume() - if input.ImageID != "" { - bootVolume.SetSource(*iaas.NewBootVolumeSource(input.ImageID, "image")) - } - if input.RootVolume.SizeGiB > 0 { - bootVolume.SetSize(int64(input.RootVolume.SizeGiB)) - } - if input.RootVolume.PerformanceClass != "" { - bootVolume.SetPerformanceClass(input.RootVolume.PerformanceClass) - } - bootVolume.SetDeleteOnTermination(input.RootVolume.DeleteOnTermination) - payload.SetBootVolume(*bootVolume) - } - if input.SSHKeyName != "" { - payload.SetKeypairName(input.SSHKeyName) - } - if input.AvailabilityZone != "" { - payload.SetAvailabilityZone(input.AvailabilityZone) - } - - server, err := c.iaasClient.DefaultAPI.CreateServer(ctx, c.projectID, c.region). - CreateServerPayload(*payload). - Execute() - if err != nil { - return nil, classifySDKError("create server", err) - } - return c.serverFromSDK(ctx, server), nil -} - -func (c *SDKClient) ListAvailabilityZones(ctx context.Context) ([]string, error) { - resp, err := c.iaasClient.DefaultAPI.ListAvailabilityZones(ctx, c.region).Execute() - if err != nil { - return nil, classifySDKError("list availability zones", err) - } - if resp == nil || resp.Items == nil { - return nil, nil - } - return resp.GetItems(), nil -} - -func (c *SDKClient) DeleteServer(ctx context.Context, id string) error { - if err := c.iaasClient.DefaultAPI.DeleteServer(ctx, c.projectID, c.region, id).Execute(); err != nil { - return classifySDKError("delete server", err) - } - return nil -} - -func (c *SDKClient) GetNetwork(ctx context.Context, id string) (*Network, error) { - network, err := c.iaasClient.DefaultAPI.GetNetwork(ctx, c.projectID, c.region, id).Execute() - if err != nil { - return nil, classifySDKError("get network", err) - } - ipv4 := network.GetIpv4() - return &Network{ - ID: network.GetId(), - Name: network.GetName(), - IPv4Prefixes: ipv4.GetPrefixes(), - }, nil -} - -func (c *SDKClient) FindNetworkByTags(ctx context.Context, tags map[string]string) (*Network, error) { - networks, err := c.ListNetworksByTags(ctx, tags) - if err != nil { - return nil, err - } - if len(networks) == 0 { - return nil, fmt.Errorf("%w: no network matching tags", ErrNotFound) - } - if len(networks) > 1 { - return nil, fmt.Errorf("%w: multiple networks matching tags", ErrConflict) - } - return networks[0], nil -} - -func (c *SDKClient) ListNetworksByTags(ctx context.Context, tags map[string]string) ([]*Network, error) { - if len(tags) == 0 { - return nil, fmt.Errorf("%w: empty tag selector", ErrInvalidInput) - } - resp, err := c.iaasClient.DefaultAPI.ListNetworks(ctx, c.projectID, c.region). - LabelSelector(labelSelector(tags)). - Execute() - if err != nil { - return nil, classifySDKError("list networks", err) - } - matched := []*Network{} - for _, net := range resp.GetItems() { - if labelsContainTags(net.GetLabels(), tags) { - ipv4 := net.GetIpv4() - matched = append(matched, &Network{ - ID: net.GetId(), - Name: net.GetName(), - IPv4Prefixes: ipv4.GetPrefixes(), - }) - } - } - return matched, nil -} - -func (c *SDKClient) CreateNetwork(ctx context.Context, input CreateNetworkInput) (*Network, error) { - if input.Name == "" { - return nil, fmt.Errorf("%w: network name is required", ErrInvalidInput) - } - - if len(input.Tags) > 0 { - if existing, err := c.FindNetworkByTags(ctx, input.Tags); err == nil { - return existing, nil - } else if !IsNotFound(err) { - return nil, err - } - } - - payload := iaas.NewCreateNetworkPayload(input.Name) - if len(input.Tags) > 0 { - payload.SetLabels(tagsToSDKLabels(input.Tags)) - } - if input.IPv4Prefix != "" { - ipv4Payload := iaas.NewCreateNetworkIPv4WithPrefix(input.IPv4Prefix) - payload.SetIpv4(iaas.CreateNetworkIPv4WithPrefixAsCreateNetworkIPv4(ipv4Payload)) - } - - network, err := c.iaasClient.DefaultAPI.CreateNetwork(ctx, c.projectID, c.region). - CreateNetworkPayload(*payload). - Execute() - if err != nil { - return nil, classifySDKError("create network", err) - } - - ipv4 := network.GetIpv4() - return &Network{ - ID: network.GetId(), - Name: network.GetName(), - IPv4Prefixes: ipv4.GetPrefixes(), - }, nil -} - -func (c *SDKClient) DeleteNetwork(ctx context.Context, id string) error { - if err := c.iaasClient.DefaultAPI.DeleteNetwork(ctx, c.projectID, c.region, id).Execute(); err != nil { - return classifySDKError("delete network", err) - } - return nil -} - -func (c *SDKClient) EnsureBastion(ctx context.Context, input BastionInput) (*Bastion, error) { - if input.Name == "" || input.NetworkID == "" || input.ImageID == "" || - input.MachineType == "" || input.SSHKeyName == "" { - return nil, fmt.Errorf( - "%w: bastion name, network ID, image ID, machine type, and SSH key name are required", - ErrInvalidInput, - ) - } - if len(input.AllowedCIDRs) == 0 { - return nil, fmt.Errorf("%w: bastion allowed CIDRs are required", ErrInvalidInput) - } - if len(input.Tags) == 0 { - return nil, fmt.Errorf("%w: bastion tags are required", ErrInvalidInput) - } - - securityGroup, err := c.ensureBastionSecurityGroup(ctx, input) - if err != nil { - return nil, err - } - if err := c.ensureBastionSecurityGroupRules(ctx, securityGroup.ID, input.AllowedCIDRs); err != nil { - return nil, err - } - - server, err := c.CreateServer(ctx, CreateServerInput{ - Name: input.Name, - ProjectID: input.ProjectID, - Region: input.Region, - ImageID: input.ImageID, - MachineType: input.MachineType, - SSHKeyName: input.SSHKeyName, - NetworkID: input.NetworkID, - SecurityGroups: []string{securityGroup.ID}, - UserData: input.CloudInit, - Tags: input.Tags, - RootVolume: input.RootVolume, - }) - if err != nil { - return nil, err - } - // The group is already in the CreateServer payload, but CreateServer - // short-circuits on an existing server found by tags — this is then the only - // path that re-attaches a group that was detached out of band (for example - // by an interrupted DeleteBastion). Kept deliberately, and idempotent: the - // duplicate/no-port-yet responses are tolerated so they can no longer abort - // the reconcile before the public IP below is assigned. - if err := c.addSecurityGroupToServer(ctx, server.ID, securityGroup.ID); err != nil { - return nil, err - } - - publicIP, err := c.ensurePublicIP(ctx, input.Tags) - if err != nil { - return nil, err - } - if publicIP.NetworkInterfaceID == "" { - if err := c.iaasClient.DefaultAPI. - AddPublicIpToServer(ctx, c.projectID, c.region, server.ID, publicIP.ID). - Execute(); err != nil { - err := classifySDKError("add public IP to server", err) - if !IsConflict(err) { - return nil, err - } - } - publicIP, err = c.getPublicIP(ctx, publicIP.ID) - if err != nil { - return nil, err - } - } - - return &Bastion{ - ServerID: server.ID, - ServerState: server.State, - ServerPowerStatus: server.PowerStatus, - PublicIPID: publicIP.ID, - PublicIP: publicIP.IP, - SecurityGroupID: securityGroup.ID, - }, nil -} - -func (c *SDKClient) DeleteBastion(ctx context.Context, input BastionInput, status Bastion) error { - serverID := status.ServerID - if serverID == "" { - server, err := c.FindServerByTags(ctx, input.Tags) - if err == nil { - serverID = server.ID - } else if !IsNotFound(err) { - return err - } - } - - publicIPID := status.PublicIPID - if publicIPID == "" { - publicIP, err := c.findPublicIPByTags(ctx, input.Tags) - if err == nil { - publicIPID = publicIP.ID - } else if !IsNotFound(err) { - return err - } - } - - securityGroupID := status.SecurityGroupID - if securityGroupID == "" { - securityGroup, err := c.findSecurityGroupByTags(ctx, input.Tags) - if err == nil { - securityGroupID = securityGroup.ID - } else if !IsNotFound(err) { - return err - } - } - - if serverID != "" && publicIPID != "" { - if err := c.iaasClient.DefaultAPI. - RemovePublicIpFromServer(ctx, c.projectID, c.region, serverID, publicIPID). - Execute(); err != nil { - err := classifySDKError("remove public IP from server", err) - if !IsNotFound(err) && !IsConflict(err) { - return err - } - } - } - if serverID != "" && securityGroupID != "" { - if err := c.iaasClient.DefaultAPI. - RemoveSecurityGroupFromServer(ctx, c.projectID, c.region, serverID, securityGroupID). - Execute(); err != nil { - err := classifySDKError("remove security group from server", err) - if !IsNotFound(err) && !IsConflict(err) { - return err - } - } - } - if serverID != "" { - if err := c.DeleteServer(ctx, serverID); err != nil && !IsNotFound(err) { - return err - } - } - if publicIPID != "" { - if err := c.iaasClient.DefaultAPI.DeletePublicIP(ctx, c.projectID, c.region, publicIPID).Execute(); err != nil { - err := classifySDKError("delete public IP", err) - if !IsNotFound(err) { - return err - } - } - } - if securityGroupID != "" { - if err := c.deleteSecurityGroupRules(ctx, securityGroupID); err != nil { - return err - } - if err := c.iaasClient.DefaultAPI. - DeleteSecurityGroup(ctx, c.projectID, c.region, securityGroupID). - Execute(); err != nil { - err := classifySDKError("delete security group", err) - if !IsNotFound(err) { - return err - } - } - } - return nil -} - -func (c *SDKClient) EnsureNodeSSHAccess(ctx context.Context, input NodeSSHAccessInput) (*SecurityGroup, error) { - if input.Name == "" || input.ServerID == "" || input.BastionSecurityGroupID == "" { - return nil, fmt.Errorf( - "%w: node SSH access name, server ID, and bastion security group ID are required", - ErrInvalidInput, - ) - } - if len(input.Tags) == 0 { - return nil, fmt.Errorf("%w: node SSH access tags are required", ErrInvalidInput) - } - - securityGroup, err := c.ensureNodeSSHSecurityGroup(ctx, input) - if err != nil { - return nil, err - } - if err := c.ensureNodeSSHSecurityGroupRule(ctx, securityGroup.ID, input.BastionSecurityGroupID); err != nil { - return nil, err - } - if err := c.addSecurityGroupToServer(ctx, input.ServerID, securityGroup.ID); err != nil { - return nil, err - } - return securityGroup, nil -} - -func (c *SDKClient) DeleteNodeSSHAccess(ctx context.Context, tags map[string]string) error { - securityGroup, err := c.findSecurityGroupByTags(ctx, tags) - if IsNotFound(err) { - return nil - } - if err != nil { - return err - } - servers, err := c.ListServersByTags(ctx, clusterServerSelectorFromTags(tags)) - if err != nil { - return err - } - for _, server := range servers { - if err := c.iaasClient.DefaultAPI. - RemoveSecurityGroupFromServer(ctx, c.projectID, c.region, server.ID, securityGroup.ID). - Execute(); err != nil { - err := classifySDKError("remove security group from server", err) - if !IsNotFound(err) && !IsConflict(err) { - return err - } - } - } - if err := c.deleteSecurityGroupRules(ctx, securityGroup.ID); err != nil { - return err - } - if err := c.iaasClient.DefaultAPI. - DeleteSecurityGroup(ctx, c.projectID, c.region, securityGroup.ID). - Execute(); err != nil { - err := classifySDKError("delete security group", err) - if !IsNotFound(err) { - return err - } - } - return nil -} - -func (c *SDKClient) ListPublicIPsByTags(ctx context.Context, tags map[string]string) ([]*PublicIP, error) { - if len(tags) == 0 { - return nil, fmt.Errorf("%w: empty tag selector", ErrInvalidInput) - } - resp, err := c.iaasClient.DefaultAPI.ListPublicIPs(ctx, c.projectID, c.region). - LabelSelector(labelSelector(tags)). - Execute() - if err != nil { - return nil, classifySDKError("list public IPs", err) - } - matched := []*PublicIP{} - for _, publicIP := range resp.GetItems() { - if labelsContainTags(publicIP.GetLabels(), tags) { - publicIP := publicIP - matched = append(matched, publicIPFromSDK(&publicIP)) - } - } - return matched, nil -} - -func (c *SDKClient) ListSecurityGroupsByTags(ctx context.Context, tags map[string]string) ([]*SecurityGroup, error) { - if len(tags) == 0 { - return nil, fmt.Errorf("%w: empty tag selector", ErrInvalidInput) - } - resp, err := c.iaasClient.DefaultAPI.ListSecurityGroups(ctx, c.projectID, c.region). - LabelSelector(labelSelector(tags)). - Execute() - if err != nil { - return nil, classifySDKError("list security groups", err) - } - matched := []*SecurityGroup{} - for _, securityGroup := range resp.GetItems() { - if labelsContainTags(securityGroup.GetLabels(), tags) { - securityGroup := securityGroup - matched = append(matched, securityGroupFromSDK(&securityGroup)) - } - } - return matched, nil -} - -func (c *SDKClient) EnsureAPIServerLoadBalancer(ctx context.Context, input LoadBalancerInput) (*LoadBalancer, error) { - if existing, err := c.findLoadBalancerByTags(ctx, input.Tags); err == nil { - return existing, nil - } else if !IsNotFound(err) && !isLoadBalancerServiceNotEnabled(err) { - return nil, err - } - payload := lb.NewCreateLoadBalancerPayload() - payload.SetName(input.Name) - payload.SetRegion(input.Region) - if len(input.Tags) > 0 { - payload.SetLabels(loadBalancerLabels(input.Tags)) - } - options := lb.NewLoadBalancerOptions() - options.SetEphemeralAddress(true) - payload.SetOptions(*options) - - network := lb.NewNetwork() - network.SetNetworkId(input.NetworkID) - network.SetRole("ROLE_LISTENERS_AND_TARGETS") - payload.SetNetworks([]lb.Network{*network}) - - targetPool := lb.NewTargetPool() - targetPool.SetName(apiserverTargetPoolName) - targetPool.SetTargetPort(input.Port) - targets := make([]lb.Target, 0, len(input.Targets)) - if len(input.Targets) == 0 { - target := lb.NewTarget() - target.SetDisplayName(bootstrapTargetName) - target.SetIp(bootstrapTargetIP) - targets = append(targets, *target) - } else { - for _, targetInput := range input.Targets { - target := lb.NewTarget() - target.SetDisplayName(targetInput.Name) - target.SetIp(targetInput.IP) - targets = append(targets, *target) - } - } - targetPool.SetTargets(targets) - payload.SetTargetPools([]lb.TargetPool{*targetPool}) - - listener := lb.NewListener() - listener.SetDisplayName(apiserverListenerName) - listener.SetPort(input.Port) - listener.SetProtocol("PROTOCOL_TCP") - listener.SetTargetPool(apiserverTargetPoolName) - payload.SetListeners([]lb.Listener{*listener}) - - lbResp, err := c.lbClient.DefaultAPI.CreateLoadBalancer(ctx, c.projectID, c.region). - CreateLoadBalancerPayload(*payload). - Execute() - if err != nil { - return nil, classifySDKError("create load balancer", err) - } - return loadBalancerFromSDK(lbResp), nil -} - -func (c *SDKClient) DeleteAPIServerLoadBalancer(ctx context.Context, id string) error { - if _, err := c.lbClient.DefaultAPI.DeleteLoadBalancer(ctx, c.projectID, c.region, id).Execute(); err != nil { - return classifySDKError("delete load balancer", err) - } - return nil -} - -func (c *SDKClient) ListAPIServerLoadBalancersByTags( - ctx context.Context, - tags map[string]string, -) ([]*LoadBalancer, error) { - if len(tags) == 0 { - return nil, fmt.Errorf("%w: empty tag selector", ErrInvalidInput) - } - resp, err := c.lbClient.DefaultAPI.ListLoadBalancers(ctx, c.projectID, c.region).Execute() - if err != nil { - err := classifySDKError("list load balancers", err) - if isLoadBalancerServiceNotEnabled(err) { - return nil, nil - } - return nil, err - } - matched := []*LoadBalancer{} - labels := loadBalancerLabels(tags) - for _, candidate := range resp.GetLoadBalancers() { - if mapContains(candidate.GetLabels(), labels) { - candidate := candidate - matched = append(matched, loadBalancerFromSDK(&candidate)) - } - } - return matched, nil -} - -func (c *SDKClient) SetAPIServerLoadBalancerTargets( - ctx context.Context, - loadBalancerID string, - port int32, - targets []LoadBalancerTargetInput, -) error { - if loadBalancerID == "" || port <= 0 { - return fmt.Errorf("%w: load balancer ID and target port are required", ErrInvalidInput) - } - // STACKIT NLB target pools must contain at least one target. - if len(targets) == 0 { - return fmt.Errorf("%w: at least one target is required", ErrInvalidInput) - } - desired := make([]lb.Target, 0, len(targets)) - for _, targetInput := range targets { - if targetInput.Name == "" || targetInput.IP == "" { - return fmt.Errorf("%w: target name and target IP are required", ErrInvalidInput) - } - target := lb.NewTarget() - target.SetDisplayName(targetInput.Name) - target.SetIp(targetInput.IP) - desired = append(desired, *target) - } - - loadBalancer, err := c.lbClient.DefaultAPI.GetLoadBalancer(ctx, c.projectID, c.region, loadBalancerID).Execute() - if err != nil { - return classifySDKError("get load balancer", err) - } - targetPool := apiServerTargetPool(loadBalancer) - if targetPool == nil { - return fmt.Errorf( - "%w: load balancer %q has no %q target pool", - ErrNotFound, - loadBalancerID, - apiserverTargetPoolName, - ) - } - - // Every cluster reconcile ends up here; skip the update call when the pool - // already matches. - if targetPool.GetTargetPort() == port && sameTargets(targetPool.GetTargets(), desired) { - return nil - } - return c.updateAPIServerTargetPool(ctx, loadBalancerID, targetPool, desired, port) -} - -func sameTargets(current, desired []lb.Target) bool { - if len(current) != len(desired) { - return false - } - return slices.Equal(sortedTargetKeys(current), sortedTargetKeys(desired)) -} - -type targetKey struct{ name, ip string } - -func sortedTargetKeys(targets []lb.Target) []targetKey { - keys := make([]targetKey, 0, len(targets)) - for _, target := range targets { - keys = append(keys, targetKey{name: target.GetDisplayName(), ip: target.GetIp()}) - } - slices.SortFunc(keys, func(a, b targetKey) int { - return cmp.Or(strings.Compare(a.name, b.name), strings.Compare(a.ip, b.ip)) - }) - return keys -} - -func (c *SDKClient) findLoadBalancerByTags(ctx context.Context, tags map[string]string) (*LoadBalancer, error) { - matched, err := c.ListAPIServerLoadBalancersByTags(ctx, tags) - if err != nil { - return nil, err - } - if len(matched) == 0 { - return nil, fmt.Errorf("%w: no load balancer matching tags", ErrNotFound) - } - if len(matched) > 1 { - return nil, fmt.Errorf("%w: multiple load balancers matching tags", ErrConflict) - } - return matched[0], nil -} - -func (c *SDKClient) ensureBastionSecurityGroup(ctx context.Context, input BastionInput) (*SecurityGroup, error) { - if existing, err := c.findSecurityGroupByTags(ctx, input.Tags); err == nil { - return existing, nil - } else if !IsNotFound(err) { - return nil, err - } - payload := iaas.NewCreateSecurityGroupPayload(input.Name + "-ssh") - payload.SetDescription("Cluster API Provider STACKIT bastion SSH access") - payload.SetLabels(tagsToSDKLabels(input.Tags)) - securityGroup, err := c.iaasClient.DefaultAPI.CreateSecurityGroup(ctx, c.projectID, c.region). - CreateSecurityGroupPayload(*payload). - Execute() - if err != nil { - return nil, classifySDKError("create security group", err) - } - return securityGroupFromSDK(securityGroup), nil -} - -func (c *SDKClient) ensureNodeSSHSecurityGroup(ctx context.Context, input NodeSSHAccessInput) (*SecurityGroup, error) { - if existing, err := c.findSecurityGroupByTags(ctx, input.Tags); err == nil { - return existing, nil - } else if !IsNotFound(err) { - return nil, err - } - payload := iaas.NewCreateSecurityGroupPayload(input.Name) - payload.SetDescription("Cluster API Provider STACKIT node SSH access from bastion") - payload.SetLabels(tagsToSDKLabels(input.Tags)) - securityGroup, err := c.iaasClient.DefaultAPI.CreateSecurityGroup(ctx, c.projectID, c.region). - CreateSecurityGroupPayload(*payload). - Execute() - if err != nil { - return nil, classifySDKError("create security group", err) - } - return securityGroupFromSDK(securityGroup), nil -} - -func (c *SDKClient) ensureBastionSecurityGroupRules(ctx context.Context, securityGroupID string, cidrs []string) error { - if securityGroupID == "" { - return fmt.Errorf("%w: security group ID is required", ErrInvalidInput) - } - resp, err := c.iaasClient.DefaultAPI.ListSecurityGroupRules(ctx, c.projectID, c.region, securityGroupID).Execute() - if err != nil { - return classifySDKError("list security group rules", err) - } - existingRules := resp.GetItems() - desired := make(map[string]struct{}, len(cidrs)) - for _, cidr := range cidrs { - if cidr == "" { - return fmt.Errorf("%w: empty bastion allowed CIDR", ErrInvalidInput) - } - if _, seen := desired[cidr]; seen { - // A CIDR listed twice would otherwise be created twice: - // existingRules is a snapshot from before this loop, so the second - // pass does not see the rule the first pass just created, and the - // duplicate create fails the whole bastion reconcile. - continue - } - desired[cidr] = struct{}{} - if hasSSHRule(existingRules, cidr) { - continue - } - protocol := iaas.StringAsCreateProtocol(new(tcpProtocol)) - rule := iaas.NewCreateSecurityGroupRulePayload("ingress") - rule.SetIpRange(cidr) - rule.SetPortRange(*iaas.NewPortRange(sshPort, sshPort)) - rule.SetProtocol(protocol) - if _, err := c.iaasClient.DefaultAPI.CreateSecurityGroupRule(ctx, c.projectID, c.region, securityGroupID). - CreateSecurityGroupRulePayload(*rule). - Execute(); err != nil { - return classifySDKError("create security group rule", err) - } - } - - // Revoke SSH rules for CIDRs that are no longer desired. Without this the - // rule set only ever grows, so narrowing allowedCIDRs would not actually - // take access away from the previously allowed range. - for _, rule := range existingRules { - if !isSSHRule(rule) { - continue - } - if _, keep := desired[rule.GetIpRange()]; keep { - continue - } - ruleID := rule.GetId() - if ruleID == "" { - continue - } - if err := c.iaasClient.DefaultAPI. - DeleteSecurityGroupRule(ctx, c.projectID, c.region, securityGroupID, ruleID). - Execute(); err != nil { - err := classifySDKError("delete security group rule", err) - if !IsNotFound(err) { - return err - } - } - } - return nil -} - -func (c *SDKClient) ensureNodeSSHSecurityGroupRule( - ctx context.Context, - nodeSecurityGroupID, bastionSecurityGroupID string, -) error { - if nodeSecurityGroupID == "" || bastionSecurityGroupID == "" { - return fmt.Errorf("%w: node and bastion security group IDs are required", ErrInvalidInput) - } - resp, err := c.iaasClient.DefaultAPI.ListSecurityGroupRules(ctx, c.projectID, c.region, nodeSecurityGroupID).Execute() - if err != nil { - return classifySDKError("list security group rules", err) - } - if hasRemoteSecurityGroupSSHRule(resp.GetItems(), bastionSecurityGroupID) { - return nil - } - protocol := iaas.StringAsCreateProtocol(new(tcpProtocol)) - rule := iaas.NewCreateSecurityGroupRulePayload("ingress") - rule.SetRemoteSecurityGroupId(bastionSecurityGroupID) - rule.SetPortRange(*iaas.NewPortRange(sshPort, sshPort)) - rule.SetProtocol(protocol) - if _, err := c.iaasClient.DefaultAPI.CreateSecurityGroupRule(ctx, c.projectID, c.region, nodeSecurityGroupID). - CreateSecurityGroupRulePayload(*rule). - Execute(); err != nil { - return classifySDKError("create security group rule", err) - } - return nil -} - -func (c *SDKClient) ensurePublicIP(ctx context.Context, tags map[string]string) (*PublicIP, error) { - if existing, err := c.findPublicIPByTags(ctx, tags); err == nil { - return existing, nil - } else if !IsNotFound(err) { - return nil, err - } - payload := iaas.NewCreatePublicIPPayload() - payload.SetLabels(tagsToSDKLabels(tags)) - publicIP, err := c.iaasClient.DefaultAPI.CreatePublicIP(ctx, c.projectID, c.region). - CreatePublicIPPayload(*payload). - Execute() - if err != nil { - return nil, classifySDKError("create public IP", err) - } - return publicIPFromSDK(publicIP), nil -} - -func (c *SDKClient) getPublicIP(ctx context.Context, id string) (*PublicIP, error) { - publicIP, err := c.iaasClient.DefaultAPI.GetPublicIP(ctx, c.projectID, c.region, id).Execute() - if err != nil { - return nil, classifySDKError("get public IP", err) - } - return publicIPFromSDK(publicIP), nil -} - -func (c *SDKClient) findPublicIPByTags(ctx context.Context, tags map[string]string) (*PublicIP, error) { - matched, err := c.ListPublicIPsByTags(ctx, tags) - if err != nil { - return nil, err - } - if len(matched) == 0 { - return nil, fmt.Errorf("%w: no public IP matching tags", ErrNotFound) - } - if len(matched) > 1 { - return nil, fmt.Errorf("%w: multiple public IPs matching tags", ErrConflict) - } - return matched[0], nil -} - -func (c *SDKClient) findSecurityGroupByTags(ctx context.Context, tags map[string]string) (*SecurityGroup, error) { - matched, err := c.ListSecurityGroupsByTags(ctx, tags) - if err != nil { - return nil, err - } - if len(matched) == 0 { - return nil, fmt.Errorf("%w: no security group matching tags", ErrNotFound) - } - if len(matched) > 1 { - return nil, fmt.Errorf("%w: multiple security groups matching tags", ErrConflict) - } - return matched[0], nil -} - -// addSecurityGroupToServer attaches the group idempotently. Three outcomes are -// expected and must not fail the caller: -// - conflict: already attached -// - invalid input: the API rejects the duplicate ("Duplicate items in the list") -// - not found: the server has no network port yet, so there is nothing to -// attach to — the next reconcile retries once it does -func (c *SDKClient) addSecurityGroupToServer(ctx context.Context, serverID, securityGroupID string) error { - if err := c.iaasClient.DefaultAPI. - AddSecurityGroupToServer(ctx, c.projectID, c.region, serverID, securityGroupID). - Execute(); err != nil { - err := classifySDKError("add security group to server", err) - if !IsConflict(err) && !IsInvalidInput(err) && !IsNotFound(err) { - return err - } - } - return nil -} - -func (c *SDKClient) deleteSecurityGroupRules(ctx context.Context, securityGroupID string) error { - resp, err := c.iaasClient.DefaultAPI.ListSecurityGroupRules(ctx, c.projectID, c.region, securityGroupID).Execute() - if err != nil { - err := classifySDKError("list security group rules", err) - if IsNotFound(err) { - return nil - } - return err - } - for _, rule := range resp.GetItems() { - ruleID := rule.GetId() - if ruleID == "" { - continue - } - if err := c.iaasClient.DefaultAPI. - DeleteSecurityGroupRule(ctx, c.projectID, c.region, securityGroupID, ruleID). - Execute(); err != nil { - err := classifySDKError("delete security group rule", err) - if !IsNotFound(err) { - return err - } - } - } - return nil -} - -func hasSSHRule(rules []iaas.SecurityGroupRule, cidr string) bool { - for _, rule := range rules { - if rule.GetIpRange() == cidr && isSSHRule(rule) { - return true - } - } - return false -} - -// isSSHRule reports whether the rule is an ingress TCP/22 rule, regardless of -// which CIDR it allows. -func isSSHRule(rule iaas.SecurityGroupRule) bool { - if rule.GetDirection() != "ingress" { - return false - } - portRange := rule.GetPortRange() - if portRange.GetMin() != sshPort || portRange.GetMax() != sshPort { - return false - } - protocol, ok := rule.GetProtocolOk() - return ok && protocol.GetName() == tcpProtocol -} - -func hasRemoteSecurityGroupSSHRule(rules []iaas.SecurityGroupRule, remoteSecurityGroupID string) bool { - for _, rule := range rules { - if rule.GetDirection() != "ingress" || rule.GetRemoteSecurityGroupId() != remoteSecurityGroupID { - continue - } - portRange := rule.GetPortRange() - if portRange.GetMin() != sshPort || portRange.GetMax() != sshPort { - continue - } - if protocol, ok := rule.GetProtocolOk(); ok && protocol.GetName() == tcpProtocol { - return true - } - } - return false -} - -func (c *SDKClient) updateAPIServerTargetPool( - ctx context.Context, - loadBalancerID string, - current *lb.TargetPool, - targets []lb.Target, - port int32, -) error { - payload := lb.NewUpdateTargetPoolPayload() - payload.SetName(apiserverTargetPoolName) - if port > 0 { - payload.SetTargetPort(port) - } else if current.GetTargetPort() > 0 { - payload.SetTargetPort(current.GetTargetPort()) - } - payload.SetTargets(targets) - if _, err := c.lbClient.DefaultAPI. - UpdateTargetPool(ctx, c.projectID, c.region, loadBalancerID, apiserverTargetPoolName). - UpdateTargetPoolPayload(*payload). - Execute(); err != nil { - return classifySDKError("update load balancer target pool", err) - } - return nil -} - -func apiServerTargetPool(loadBalancer *lb.LoadBalancer) *lb.TargetPool { - if loadBalancer == nil { - return nil - } - for _, targetPool := range loadBalancer.GetTargetPools() { - if targetPool.GetName() == apiserverTargetPoolName { - return &targetPool - } - } - return nil -} - -func (c *SDKClient) serverFromSDK(ctx context.Context, server *iaas.Server) *Server { - if server == nil { - return nil - } - out := &Server{ - ID: server.GetId(), - Name: server.GetName(), - State: server.GetStatus(), - PowerStatus: server.GetPowerStatus(), - AvailabilityZone: server.GetAvailabilityZone(), - } - nics, err := c.iaasClient.DefaultAPI.ListServerNICs(ctx, c.projectID, c.region, out.ID).Execute() - if err == nil { - for _, nic := range nics.GetItems() { - if ipv4 := nic.GetIpv4(); ipv4 != "" { - out.Addresses = append(out.Addresses, Address{Type: "InternalIP", Address: ipv4}) - } - if ipv6 := nic.GetIpv6(); ipv6 != "" { - out.Addresses = append(out.Addresses, Address{Type: "InternalIP", Address: ipv6}) - } - } - } - return out -} - -func loadBalancerFromSDK(in *lb.LoadBalancer) *LoadBalancer { - if in == nil { - return nil - } - return &LoadBalancer{ - ID: in.GetName(), - Name: in.GetName(), - IP: firstNonEmpty(in.GetExternalAddress(), in.GetPrivateAddress()), - Port: listenerPort(in.GetListeners()), - } -} - -func publicIPFromSDK(in *iaas.PublicIp) *PublicIP { - if in == nil { - return nil - } - return &PublicIP{ - ID: in.GetId(), - IP: in.GetIp(), - NetworkInterfaceID: in.GetNetworkInterface(), - } -} - -func securityGroupFromSDK(in *iaas.SecurityGroup) *SecurityGroup { - if in == nil { - return nil - } - return &SecurityGroup{ - ID: in.GetId(), - Name: in.GetName(), - } -} - -func listenerPort(listeners []lb.Listener) int32 { - for _, listener := range listeners { - if port := listener.GetPort(); port > 0 { - return port - } - } - return 0 -} - -func labelSelector(tags map[string]string) string { - parts := make([]string, 0, len(tags)) - for k, v := range tags { - parts = append(parts, k+"="+v) - } - return strings.Join(parts, ",") -} - -func labelsContainTags(labels map[string]any, tags map[string]string) bool { - for k, want := range tags { - got, ok := labels[k] - if !ok || fmt.Sprint(got) != want { - return false - } - } - return true -} - -func tagsToSDKLabels(tags map[string]string) map[string]any { - out := make(map[string]any, len(tags)) - for k, v := range tags { - out[k] = v - } - return out -} - -func clusterServerSelectorFromTags(tags map[string]string) map[string]string { - selector := map[string]string{} - for _, key := range []string{ - "cluster.x-k8s.io/cluster-name", - "cluster.x-k8s.io/cluster-namespace", - "cluster.x-k8s.io/managed-by", - } { - if value := tags[key]; value != "" { - selector[key] = value - } - } - return selector -} - -func mapContains(haystack, needle map[string]string) bool { - for k, v := range needle { - if haystack[k] != v { - return false - } - } - return true -} - -func loadBalancerLabels(tags map[string]string) map[string]string { - out := make(map[string]string, len(tags)) - for k, v := range tags { - out[strings.ReplaceAll(k, "/", ".")] = v - } - return out -} - -func firstNonEmpty(values ...string) string { - for _, value := range values { - if value != "" { - return value - } - } - return "" -} - -func classifySDKError(op string, err error) error { - var oapiErr *oapierror.GenericOpenAPIError - if errors.As(err, &oapiErr) { - switch oapiErr.StatusCode { - case http.StatusNotFound: - return fmt.Errorf("%w: %s: %v", ErrNotFound, op, err) - case http.StatusUnauthorized, http.StatusForbidden: - return fmt.Errorf("%w: %s: %v", ErrUnauthorized, op, err) - case http.StatusConflict: - return fmt.Errorf("%w: %s: %v", ErrConflict, op, err) - case http.StatusBadRequest, http.StatusUnprocessableEntity: - return fmt.Errorf("%w: %s: %v", ErrInvalidInput, op, err) - case http.StatusTooManyRequests: - return fmt.Errorf("%w: %s: %v", ErrTransient, op, err) - default: - if oapiErr.StatusCode >= 500 { - return fmt.Errorf("%w: %s: %v", ErrTransient, op, err) - } - } - } - return fmt.Errorf("%w: %s: %v", ErrTransient, op, err) -} - -func isLoadBalancerServiceNotEnabled(err error) bool { - return IsUnauthorized(err) && strings.Contains(err.Error(), "Service not enabled") -} diff --git a/cloud/sdk_client_integration_test.go b/cloud/sdk_client_integration_test.go index 0fd1594..8cb1e14 100644 --- a/cloud/sdk_client_integration_test.go +++ b/cloud/sdk_client_integration_test.go @@ -20,6 +20,9 @@ import ( "os" "testing" "time" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" ) const ( @@ -34,16 +37,15 @@ const ( func TestSDKClientCredentialsIntegration(t *testing.T) { client := newIntegrationClient(t) - _, err := client.FindServerByTags(context.Background(), map[string]string{ + ids, err := shared.ListServerIDsByTags(context.Background(), client, map[string]string{ "capistackit-test": "credential-check", }) - if IsNotFound(err) { - return - } if err != nil { - t.Fatalf("FindServerByTags() error = %v", err) + t.Fatalf("ListServerIDsByTags() error = %v", err) + } + if len(ids) > 0 { + t.Fatal("ListServerIDsByTags() unexpectedly found a server matching integration-test tags") } - t.Fatal("FindServerByTags() unexpectedly found a server matching integration-test tags") } func TestSDKClientListNetworksIntegration(t *testing.T) { @@ -66,13 +68,13 @@ func TestSDKClientLoadBalancerCreateDeleteIntegration(t *testing.T) { client := newIntegrationClient(t) networkID := requiredIntegrationEnv(t, envIntegrationNetworkID) targetIP := requiredIntegrationEnv(t, envIntegrationTargetIP) - loadBalancer := createIntegrationLoadBalancer(t, client, networkID, LoadBalancerTargetInput{ + scope := createIntegrationLoadBalancer(t, client, networkID, loadbalancer.Target{ Name: "capistackit-initial-target", IP: targetIP, }) - if err := client.DeleteAPIServerLoadBalancer(context.Background(), loadBalancer.ID); err != nil { - t.Fatalf("DeleteAPIServerLoadBalancer() error = %v", err) + if err := loadbalancer.New(scope).Delete(context.Background()); err != nil { + t.Fatalf("loadbalancer.Delete() error = %v", err) } } @@ -81,25 +83,23 @@ func TestSDKClientLoadBalancerTargetIntegration(t *testing.T) { networkID := requiredIntegrationEnv(t, envIntegrationNetworkID) targetIP := requiredIntegrationEnv(t, envIntegrationTargetIP) initialIP := integrationInitialTargetIP(targetIP) - loadBalancer := createIntegrationLoadBalancer(t, client, networkID, LoadBalancerTargetInput{ + scope := createIntegrationLoadBalancer(t, client, networkID, loadbalancer.Target{ Name: "capistackit-initial-target", IP: initialIP, }) - t.Cleanup(func() { - if err := client.DeleteAPIServerLoadBalancer(context.Background(), loadBalancer.ID); err != nil && !IsNotFound(err) { - t.Logf("DeleteAPIServerLoadBalancer() cleanup error = %v", err) - } - }) - targets := []LoadBalancerTargetInput{ + targets := []loadbalancer.Target{ {Name: "capistackit-initial-target", IP: initialIP}, {Name: "capistackit-integration-target", IP: targetIP}, } - if err := client.SetAPIServerLoadBalancerTargets(context.Background(), loadBalancer.ID, 6443, targets); err != nil { - t.Fatalf("SetAPIServerLoadBalancerTargets() error = %v", err) + scope.spec.Targets = targets + svc := loadbalancer.New(scope) + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("loadbalancer.Reconcile() error = %v", err) } - if err := client.SetAPIServerLoadBalancerTargets(context.Background(), loadBalancer.ID, 6443, targets[:1]); err != nil { - t.Fatalf("SetAPIServerLoadBalancerTargets() shrink error = %v", err) + scope.spec.Targets = targets[:1] + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("loadbalancer.Reconcile() shrink error = %v", err) } } @@ -175,42 +175,51 @@ func serviceAccountProjectID(t *testing.T, serviceAccountJSON []byte) string { return key.ProjectID } -func createIntegrationLoadBalancer(t *testing.T, client Client, networkID string, target LoadBalancerTargetInput) *LoadBalancer { +type integrationLBScope struct { + Client + spec loadbalancer.LoadBalancerSpec +} + +func (s *integrationLBScope) LoadBalancerSpec() loadbalancer.LoadBalancerSpec { + return s.spec +} + +func createIntegrationLoadBalancer(t *testing.T, client Client, networkID string, target loadbalancer.Target) *integrationLBScope { t.Helper() name := fmt.Sprintf("capistackit-it-%d", time.Now().UnixNano()) - loadBalancer, err := client.EnsureAPIServerLoadBalancer(context.Background(), LoadBalancerInput{ - Name: name, - Region: integrationRegion(), - NetworkID: networkID, - Port: 6443, - Targets: []LoadBalancerTargetInput{target}, - Tags: map[string]string{ - "capistackit-test": "true", - "capistackit-name": name, + var scope *integrationLBScope + scope = &integrationLBScope{ + Client: client, + spec: loadbalancer.LoadBalancerSpec{ + Name: name, + NetworkID: networkID, + Port: 6443, + SeedTargets: []loadbalancer.Target{target}, + Tags: map[string]string{ + "capistackit-test": "true", + "capistackit-name": name, + }, + SetLoadBalancer: func(apiServerLB *loadbalancer.LoadBalancer, _ bool) { + if apiServerLB != nil { + scope.spec.ID = apiServerLB.ID + } + }, }, - }) - if err != nil { - t.Fatalf("EnsureAPIServerLoadBalancer() error = %v", err) } - if loadBalancer == nil || loadBalancer.ID == "" { - t.Fatalf("EnsureAPIServerLoadBalancer() = %#v, want load balancer with ID", loadBalancer) + if err := loadbalancer.New(scope).Reconcile(context.Background()); err != nil { + t.Fatalf("loadbalancer.Reconcile() error = %v", err) + } + if scope.spec.ID == "" { + t.Fatal("loadbalancer.Reconcile() did not record a load balancer ID") } t.Cleanup(func() { - if err := client.DeleteAPIServerLoadBalancer(context.Background(), loadBalancer.ID); err != nil && - !IsNotFound(err) && - !errors.Is(err, ErrInvalidInput) { - t.Logf("DeleteAPIServerLoadBalancer() cleanup error = %v", err) + if err := loadbalancer.New(scope).Delete(context.Background()); err != nil && + !errors.Is(err, shared.ErrInvalidInput) { + t.Logf("loadbalancer.Delete() cleanup error = %v", err) } }) - return loadBalancer -} - -func integrationRegion() string { - if region := os.Getenv(envIntegrationRegion); region != "" { - return region - } - return "eu01" + return scope } func integrationInitialTargetIP(targetIP string) string { diff --git a/cloud/sdk_client_test.go b/cloud/sdk_client_test.go index b38f621..d3d1856 100644 --- a/cloud/sdk_client_test.go +++ b/cloud/sdk_client_test.go @@ -12,811 +12,64 @@ package cloud import ( "context" - "encoding/json" - "net/http" - "net/http/httptest" - "strings" - "sync" + "errors" "testing" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" ) const ( - testSDKProjectID = "00000000-0000-0000-0000-000000000000" - testSDKRegion = "eu01" - testSDKServerID = "33333333-3333-4333-8333-333333333333" - testSDKNetworkID = "11111111-1111-4111-8111-111111111111" - testSDKImageID = "22222222-2222-4222-8222-222222222222" - testSDKSecurityGroup = "44444444-4444-4444-8444-444444444444" - testBoolTrue = "true" - testSDKPublicIP = "203.0.113.10" + testSDKProjectID = "00000000-0000-0000-0000-000000000000" + testSDKRegion = "eu01" + testBoolTrue = "true" ) -func TestSDKClientCreateServerUsesExpectedPayload(t *testing.T) { - var createPayload map[string]any - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - switch { - case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers"): - if got := r.URL.Query().Get("label_selector"); got != "cluster=test" { - t.Fatalf("label_selector = %q, want cluster=test", got) - } - if got := r.URL.Query().Get("details"); got != testBoolTrue { - t.Fatalf("details = %q, want true", got) - } - writeJSON(t, w, map[string]any{"items": []any{}}) - case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/servers"): - createPayload = readJSON(t, r) - writeJSON(t, w, map[string]any{ - "id": testSDKServerID, - "machineType": "c2i.2", - "name": "node-0", - "status": "ACTIVE", - }) - case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers/"+testSDKServerID+"/nics"): - writeJSON(t, w, map[string]any{ - "items": []any{ - map[string]any{"ipv4": "10.0.0.10", "ipv6": "fd00::10"}, - }, - }) - default: - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) - } - })) - - client := newTestSDKClient(t, server.URL) - created, err := client.CreateServer(context.Background(), CreateServerInput{ - Name: "node-0", - MachineType: "c2i.2", - ImageID: testSDKImageID, - AvailabilityZone: "eu01-1", - SSHKeyName: "default", - NetworkID: testSDKNetworkID, - SecurityGroups: []string{testSDKSecurityGroup}, - UserData: []byte("#cloud-config\n"), - RootVolume: RootVolumeInput{ - SizeGiB: 50, - PerformanceClass: "storage_premium_perf6", - DeleteOnTermination: true, - }, - Tags: map[string]string{"cluster": "test"}, - }) - if err != nil { - t.Fatalf("CreateServer() error = %v", err) - } - if created.ID != testSDKServerID || created.Name != "node-0" || created.State != "ACTIVE" { - t.Fatalf("CreateServer() = %#v", created) - } - if len(created.Addresses) != 2 { - t.Fatalf("CreateServer() addresses = %#v, want two internal addresses", created.Addresses) - } - - assertStringField(t, createPayload, "name", "node-0") - assertStringField(t, createPayload, "machineType", "c2i.2") - assertFieldAbsent(t, createPayload, "imageId") - assertStringField(t, createPayload, "availabilityZone", "eu01-1") - assertStringField(t, createPayload, "keypairName", "default") - assertStringField(t, createPayload, "userData", "I2Nsb3VkLWNvbmZpZwo=") - assertBoolField(t, createPayload, "configDrive", true) - assertNestedStringField(t, createPayload, []string{"labels", "cluster"}, "test") - assertNestedStringField(t, createPayload, []string{"networking", "networkId"}, testSDKNetworkID) - assertNestedStringField(t, createPayload, []string{"bootVolume", "performanceClass"}, "storage_premium_perf6") - assertNestedStringField(t, createPayload, []string{"bootVolume", "source", "id"}, testSDKImageID) - assertNestedStringField(t, createPayload, []string{"bootVolume", "source", "type"}, "image") - assertNestedNumberField(t, createPayload, []string{"bootVolume", "size"}, 50) -} - -func assertFieldAbsent(t *testing.T, payload map[string]any, key string) { - t.Helper() - if _, ok := payload[key]; ok { - t.Fatalf("%s present in payload, want absent: %#v", key, payload[key]) - } -} - -func TestSDKClientEnsureAPIServerLoadBalancerCreatesExpectedPayload(t *testing.T) { - var createPayload map[string]any - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - switch { - case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/load-balancers"): - writeJSON(t, w, map[string]any{"loadBalancers": []any{}}) - case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/load-balancers"): - createPayload = readJSON(t, r) - writeJSON(t, w, sdkLoadBalancerJSON("apiserver-test", "203.0.113.10", []any{ - map[string]any{"name": apiserverTargetPoolName, "targetPort": 6443, "targets": []any{ - map[string]any{"displayName": "cp-0", "ip": "10.0.0.10"}, - }}, - })) - default: - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) +func TestNewClientValidation(t *testing.T) { + t.Run("rejects empty project ID", func(t *testing.T) { + _, err := NewClient(context.Background(), Credentials{ + Region: testSDKRegion, + ServiceAccountJSON: []byte(`{}`), + }) + if !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("NewClient() error = %v, want shared.ErrInvalidInput", err) } - })) - - client := newTestSDKClient(t, server.URL) - loadBalancer, err := client.EnsureAPIServerLoadBalancer(context.Background(), LoadBalancerInput{ - Name: "apiserver-test", - Region: testSDKRegion, - NetworkID: testSDKNetworkID, - Port: 6443, - Targets: []LoadBalancerTargetInput{{ - Name: "cp-0", - IP: "10.0.0.10", - }}, - Tags: map[string]string{ - "cluster.x-k8s.io/cluster-name": "test", - "cluster-api-provider-stackit/test-id": "run-1", - }, }) - if err != nil { - t.Fatalf("EnsureAPIServerLoadBalancer() error = %v", err) - } - if loadBalancer.ID != "apiserver-test" || loadBalancer.IP != testSDKPublicIP || loadBalancer.Port != 6443 { - t.Fatalf("EnsureAPIServerLoadBalancer() = %#v", loadBalancer) - } - assertStringField(t, createPayload, "name", "apiserver-test") - assertStringField(t, createPayload, "region", testSDKRegion) - assertNestedStringField(t, createPayload, []string{"labels", "cluster.x-k8s.io.cluster-name"}, "test") - assertNestedStringField(t, createPayload, []string{"labels", "cluster-api-provider-stackit.test-id"}, "run-1") - assertNestedBoolField(t, createPayload, []string{"options", "ephemeralAddress"}, true) - assertNestedStringField(t, createPayload, []string{"networks", "0", "networkId"}, testSDKNetworkID) - assertNestedStringField(t, createPayload, []string{"networks", "0", "role"}, "ROLE_LISTENERS_AND_TARGETS") - assertNestedStringField(t, createPayload, []string{"targetPools", "0", "name"}, apiserverTargetPoolName) - assertNestedNumberField(t, createPayload, []string{"targetPools", "0", "targetPort"}, 6443) - assertNestedStringField(t, createPayload, []string{"targetPools", "0", "targets", "0", "displayName"}, "cp-0") - assertNestedStringField(t, createPayload, []string{"targetPools", "0", "targets", "0", "ip"}, "10.0.0.10") - assertNestedStringField(t, createPayload, []string{"listeners", "0", "targetPool"}, apiserverTargetPoolName) - assertNestedNumberField(t, createPayload, []string{"listeners", "0", "port"}, 6443) -} - -func TestSDKClientEnsureAPIServerLoadBalancerUsesBootstrapTargetWhenInitialTargetsAreEmpty(t *testing.T) { - var createPayload map[string]any - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - switch { - case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/load-balancers"): - writeJSON(t, w, map[string]any{"loadBalancers": []any{}}) - case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/load-balancers"): - createPayload = readJSON(t, r) - writeJSON(t, w, sdkLoadBalancerJSON("apiserver-test", "203.0.113.10", []any{ - map[string]any{"name": apiserverTargetPoolName, "targetPort": 6443, "targets": []any{ - map[string]any{"displayName": bootstrapTargetName, "ip": bootstrapTargetIP}, - }}, - })) - default: - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + t.Run("rejects empty region", func(t *testing.T) { + _, err := NewClient(context.Background(), Credentials{ + ProjectID: testSDKProjectID, + ServiceAccountJSON: []byte(`{}`), + }) + if !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("NewClient() error = %v, want shared.ErrInvalidInput", err) } - })) - - client := newTestSDKClient(t, server.URL) - loadBalancer, err := client.EnsureAPIServerLoadBalancer(context.Background(), LoadBalancerInput{ - Name: "apiserver-test", - Region: testSDKRegion, - NetworkID: testSDKNetworkID, - Port: 6443, - Tags: map[string]string{ - "cluster.x-k8s.io/cluster-name": "test", - }, }) - if err != nil { - t.Fatalf("EnsureAPIServerLoadBalancer() error = %v", err) - } - if loadBalancer.ID != "apiserver-test" || loadBalancer.IP != "203.0.113.10" || loadBalancer.Port != 6443 { - t.Fatalf("EnsureAPIServerLoadBalancer() = %#v", loadBalancer) - } - - assertNestedStringField( - t, - createPayload, - []string{"targetPools", "0", "targets", "0", "displayName"}, - bootstrapTargetName, - ) - assertNestedStringField(t, createPayload, []string{"targetPools", "0", "targets", "0", "ip"}, bootstrapTargetIP) - assertNestedStringField(t, createPayload, []string{"listeners", "0", "targetPool"}, apiserverTargetPoolName) -} - -func TestSDKClientSetsAPIServerTargetPool(t *testing.T) { - var mu sync.Mutex - targets := []any{ - map[string]any{"displayName": "cp-0", "ip": "10.0.0.10"}, - } - var updatePayloads []map[string]any - - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - mu.Lock() - defer mu.Unlock() - - switch { - case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/load-balancers/apiserver-test"): - writeJSON(t, w, sdkLoadBalancerJSON("apiserver-test", "203.0.113.10", []any{ - map[string]any{"name": apiserverTargetPoolName, "targetPort": 6443, "targets": targets}, - })) - case r.Method == http.MethodPut && - strings.HasSuffix(r.URL.Path, "/load-balancers/apiserver-test/target-pools/"+apiserverTargetPoolName): - payload := readJSON(t, r) - updatePayloads = append(updatePayloads, payload) - next, ok := lookup(payload, "targets").([]any) - if !ok { - t.Fatalf("update target payload missing targets: %#v", payload) - } - targets = next - writeJSON(t, w, map[string]any{ - "name": apiserverTargetPoolName, - "targetPort": 6443, - "targets": targets, - }) - default: - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) - } - })) - - client := newTestSDKClient(t, server.URL) - desired := []LoadBalancerTargetInput{ - {Name: "cp-0", IP: "10.0.0.10"}, - {Name: "cp-1", IP: "10.0.0.11"}, - } - if err := client.SetAPIServerLoadBalancerTargets(context.Background(), "apiserver-test", 6443, desired); err != nil { - t.Fatalf("SetAPIServerLoadBalancerTargets() error = %v", err) - } - if len(updatePayloads) != 1 { - t.Fatalf("got %d update payloads, want 1", len(updatePayloads)) - } - assertNestedStringField(t, updatePayloads[0], []string{"targets", "0", "displayName"}, "cp-0") - assertNestedStringField(t, updatePayloads[0], []string{"targets", "1", "displayName"}, "cp-1") - assertNestedStringField(t, updatePayloads[0], []string{"targets", "1", "ip"}, "10.0.0.11") - - // An unchanged pool must not turn into a write. - if err := client.SetAPIServerLoadBalancerTargets(context.Background(), "apiserver-test", 6443, desired); err != nil { - t.Fatalf("SetAPIServerLoadBalancerTargets() repeat error = %v", err) - } - if len(updatePayloads) != 1 { - t.Fatalf("got %d update payloads after an unchanged set, want 1", len(updatePayloads)) - } - if err := client.SetAPIServerLoadBalancerTargets( - context.Background(), - "apiserver-test", - 6443, - desired[:1], - ); err != nil { - t.Fatalf("SetAPIServerLoadBalancerTargets() shrink error = %v", err) - } - if len(updatePayloads) != 2 { - t.Fatalf("got %d update payloads, want 2", len(updatePayloads)) - } - if got := nestedValue(t, updatePayloads[1], []string{"targets"}).([]any); len(got) != 1 { - t.Fatalf("shrunk target payload targets = %#v, want one remaining target", got) - } - assertNestedStringField(t, updatePayloads[1], []string{"targets", "0", "displayName"}, "cp-0") -} - -func TestSDKClientRejectsEmptyAPIServerTargetPool(t *testing.T) { - server := newSDKTestServer(t, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) - })) - - client := newTestSDKClient(t, server.URL) - err := client.SetAPIServerLoadBalancerTargets(context.Background(), "apiserver-test", 6443, nil) - if !IsInvalidInput(err) { - t.Fatalf("SetAPIServerLoadBalancerTargets() error = %v, want ErrInvalidInput", err) - } -} - -func TestSDKClientClassifiesHTTPStatusCodes(t *testing.T) { - tests := []struct { - name string - status int - check func(error) bool - }{ - {name: "not found", status: http.StatusNotFound, check: IsNotFound}, - {name: "unauthorized", status: http.StatusUnauthorized, check: IsUnauthorized}, - {name: "conflict", status: http.StatusConflict, check: IsConflict}, - {name: "invalid input", status: http.StatusBadRequest, check: IsInvalidInput}, - {name: "rate limited", status: http.StatusTooManyRequests, check: IsTransient}, - {name: "server error", status: http.StatusInternalServerError, check: IsTransient}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { - http.Error(w, http.StatusText(tt.status), tt.status) - })) - client := newTestSDKClient(t, server.URL) - - _, err := client.GetServer(context.Background(), testSDKServerID) - if err == nil { - t.Fatal("GetServer() error = nil") - } - if !tt.check(err) { - t.Fatalf("GetServer() error = %v, did not match expected classifier", err) - } + t.Run("rejects empty service account JSON when STACKIT_NO_AUTH is not true", func(t *testing.T) { + t.Setenv(stackitNoAuthEnv, "false") + _, err := NewClient(context.Background(), Credentials{ + ProjectID: testSDKProjectID, + Region: testSDKRegion, }) - } -} - -func newSDKTestServer(t *testing.T, handler http.Handler) *httptest.Server { - t.Helper() - - server := httptest.NewServer(handler) - t.Cleanup(server.Close) - return server -} - -func newTestSDKClient(t *testing.T, endpoint string) *SDKClient { - t.Helper() - - t.Setenv(stackitNoAuthEnv, testBoolTrue) - t.Setenv(stackitIAASEndpointEnv, endpoint) - t.Setenv(stackitLBEndpointEnv, endpoint) - - client, err := NewClient(context.Background(), Credentials{ - ProjectID: testSDKProjectID, - Region: testSDKRegion, - }) - if err != nil { - t.Fatalf("NewClient() error = %v", err) - } - sdkClient, ok := client.(*SDKClient) - if !ok { - t.Fatalf("NewClient() = %T, want *SDKClient", client) - } - return sdkClient -} - -func sdkLoadBalancerJSON(name, externalAddress string, targetPools []any) map[string]any { - return map[string]any{ - "name": name, - "externalAddress": externalAddress, - "listeners": []any{ - map[string]any{"displayName": apiserverListenerName, "port": 6443, "targetPool": apiserverTargetPoolName}, - }, - "targetPools": targetPools, - } -} - -func readJSON(t *testing.T, r *http.Request) map[string]any { - t.Helper() - - var out map[string]any - if err := json.NewDecoder(r.Body).Decode(&out); err != nil { - t.Fatalf("decode request body: %v", err) - } - return out -} - -func writeJSON(t *testing.T, w http.ResponseWriter, value any) { - t.Helper() - - w.Header().Set("Content-Type", "application/json") - if err := json.NewEncoder(w).Encode(value); err != nil { - t.Fatalf("encode response body: %v", err) - } -} - -func assertStringField(t *testing.T, m map[string]any, key, want string) { - t.Helper() - if got := lookup(m, key); got != want { - t.Fatalf("%s = %#v, want %q in %#v", key, got, want, m) - } -} - -func assertBoolField(t *testing.T, m map[string]any, key string, want bool) { - t.Helper() - if got := lookup(m, key); got != want { - t.Fatalf("%s = %#v, want %t in %#v", key, got, want, m) - } -} - -func assertNestedStringField(t *testing.T, m map[string]any, path []string, want string) { - t.Helper() - if got := nestedValue(t, m, path); got != want { - t.Fatalf("%s = %#v, want %q in %#v", strings.Join(path, "."), got, want, m) - } -} - -func assertNestedBoolField(t *testing.T, m map[string]any, path []string, want bool) { - t.Helper() - if got := nestedValue(t, m, path); got != want { - t.Fatalf("%s = %#v, want %t in %#v", strings.Join(path, "."), got, want, m) - } -} - -func assertNestedNumberField(t *testing.T, m map[string]any, path []string, want float64) { - t.Helper() - if got := nestedValue(t, m, path); got != want { - t.Fatalf("%s = %#v, want %v in %#v", strings.Join(path, "."), got, want, m) - } -} - -func nestedValue(t *testing.T, m map[string]any, path []string) any { - t.Helper() - - var current any = m - for _, part := range path { - switch typed := current.(type) { - case map[string]any: - current = lookup(typed, part) - case []any: - if len(part) != 1 || part[0] < '0' || part[0] > '9' { - t.Fatalf("path element %q cannot index %#v", part, typed) - } - index := int(part[0] - '0') - if index >= len(typed) { - t.Fatalf("path element %q out of range for %#v", part, typed) - } - current = typed[index] - default: - t.Fatalf("path element %q cannot descend into %#v", part, typed) - } - } - return current -} - -func lookup(m map[string]any, key string) any { - for _, candidate := range []string{ - key, - strings.ToUpper(key[:1]) + key[1:], - } { - if value, ok := m[candidate]; ok { - return value + if !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("NewClient() error = %v, want shared.ErrInvalidInput", err) } - } - return nil -} - -// TestSDKClientEnsureBastionToleratesDuplicateSecurityGroupAttach guards the -// idempotency of the security-group attach. The group is already in the create -// payload, so the attach usually hits a duplicate ("400 Duplicate items in the -// list") or a server without a port yet ("404 ... as device id on any ports"). -// Neither may abort EnsureBastion — that used to leave the public IP unassigned -// for a full reconcile cycle. The attach itself is kept because CreateServer -// short-circuits on an existing server, making this the only re-attach path. -func TestSDKClientEnsureBastionToleratesDuplicateSecurityGroupAttach(t *testing.T) { - var ( - createPayload map[string]any - attachCallCount int - publicIPAssigned bool - ) - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - path := r.URL.Path - switch { - case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): - writeJSON(t, w, map[string]any{"items": []any{ - map[string]any{ - "id": testSDKSecurityGroup, "name": "bastion-ssh", - "labels": map[string]any{"cluster": "test"}, - }, - }}) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/rules"): - writeJSON(t, w, map[string]any{"items": []any{}}) - case r.Method == http.MethodPost && strings.HasSuffix(path, "/rules"): - writeJSON(t, w, map[string]any{"id": "77777777-7777-4777-8777-777777777777", "direction": "ingress"}) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/servers"): - writeJSON(t, w, map[string]any{"items": []any{}}) - case r.Method == http.MethodPost && strings.HasSuffix(path, "/servers"): - createPayload = readJSON(t, r) - writeJSON(t, w, map[string]any{ - "id": testSDKServerID, "name": "bastion", "status": "ACTIVE", "machineType": "c2i.1", - }) - case strings.Contains(path, "/security-groups/") && strings.Contains(path, "/servers/"): - // Answer the way the real API does for an already-attached group. - attachCallCount++ - w.WriteHeader(http.StatusBadRequest) - writeJSON(t, w, map[string]any{ - "code": 400, - "msg": "request invalid: Invalid input for security_groups. Reason: Duplicate items in the list.", - }) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/public-ips"): - writeJSON(t, w, map[string]any{"items": []any{}}) - case r.Method == http.MethodPost && strings.HasSuffix(path, "/public-ips"): - writeJSON(t, w, map[string]any{"id": "66666666-6666-4666-8666-666666666666", "ip": "203.0.113.10"}) - case strings.Contains(path, "/public-ips/"): - publicIPAssigned = true - writeJSON(t, w, map[string]any{"id": "66666666-6666-4666-8666-666666666666", "ip": "203.0.113.10"}) - case r.Method == http.MethodGet && strings.Contains(path, "/servers/"): - writeJSON(t, w, map[string]any{ - "id": testSDKServerID, "name": "bastion", "status": "ACTIVE", "machineType": "c2i.1", - }) - default: - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) - } - })) - - client := newTestSDKClient(t, server.URL) - bastion, err := client.EnsureBastion(context.Background(), BastionInput{ - Name: "bastion", - ProjectID: testSDKProjectID, - Region: testSDKRegion, - NetworkID: testSDKNetworkID, - ImageID: testSDKImageID, - MachineType: "c2i.1", - SSHKeyName: "default", - AllowedCIDRs: []string{"203.0.113.0/24"}, - Tags: map[string]string{"cluster": "test"}, }) - if err != nil { - t.Fatalf("EnsureBastion() error = %v", err) - } - if attachCallCount != 1 { - t.Fatalf("attach attempted %d time(s), want exactly 1 (the idempotent re-attach)", attachCallCount) - } - groups, _ := createPayload["securityGroups"].([]any) - if len(groups) != 1 || groups[0] != testSDKSecurityGroup { - t.Fatalf("create payload securityGroups = %v, want [%s]", createPayload["securityGroups"], testSDKSecurityGroup) - } - if !publicIPAssigned { - t.Fatal("public IP was never assigned to the bastion server") - } - if bastion.PublicIP != "203.0.113.10" { - t.Fatalf("bastion.PublicIP = %q, want 203.0.113.10", bastion.PublicIP) - } -} - -// TestSDKClientEnsureBastionRevokesRemovedCIDR guards against security-group -// rules only ever being added. Narrowing allowedCIDRs must actually take -// access away from the previously allowed range. -func TestSDKClientEnsureBastionRevokesRemovedCIDR(t *testing.T) { - const staleRuleID = "55555555-5555-4555-8555-555555555555" - var ( - createdRuleCIDRs []string - deletedRuleIDs []string - ) - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - path := r.URL.Path - switch { - case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): - writeJSON(t, w, map[string]any{"items": []any{ - map[string]any{ - "id": testSDKSecurityGroup, "name": "bastion-ssh", - "labels": map[string]any{"cluster": "test"}, - }, - }}) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/rules"): - // One pre-existing SSH rule for the CIDR that is being revoked. - writeJSON(t, w, map[string]any{"items": []any{ - map[string]any{ - "id": staleRuleID, - "direction": "ingress", - "ipRange": "198.51.100.0/24", - "portRange": map[string]any{"min": 22, "max": 22}, - "protocol": map[string]any{"name": "tcp"}, - }, - }}) - case r.Method == http.MethodPost && strings.HasSuffix(path, "/rules"): - payload := readJSON(t, r) - if cidr, ok := payload["ipRange"].(string); ok { - createdRuleCIDRs = append(createdRuleCIDRs, cidr) - } - writeJSON(t, w, map[string]any{"id": "77777777-7777-4777-8777-777777777777", "direction": "ingress"}) - case strings.Contains(path, "/security-groups/") && strings.Contains(path, "/servers/"): - w.WriteHeader(http.StatusNoContent) - case r.Method == http.MethodDelete && strings.Contains(path, "/rules/"): - parts := strings.Split(strings.TrimSuffix(path, "/"), "/") - deletedRuleIDs = append(deletedRuleIDs, parts[len(parts)-1]) - w.WriteHeader(http.StatusNoContent) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/servers"): - writeJSON(t, w, map[string]any{"items": []any{ - map[string]any{ - "id": testSDKServerID, "name": "bastion", "status": "ACTIVE", "machineType": "c2i.1", - "labels": map[string]any{"cluster": "test"}, - }, - }}) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/public-ips"): - writeJSON(t, w, map[string]any{"items": []any{ - map[string]any{ - "id": "66666666-6666-4666-8666-666666666666", "ip": "203.0.113.10", "networkInterface": "nic-1", - "labels": map[string]any{"cluster": "test"}, - }, - }}) - case r.Method == http.MethodGet && strings.Contains(path, "/servers/"): - writeJSON(t, w, map[string]any{ - "id": testSDKServerID, "name": "bastion", "status": "ACTIVE", "machineType": "c2i.1", - }) - default: - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) - } - })) - - client := newTestSDKClient(t, server.URL) - if _, err := client.EnsureBastion(context.Background(), BastionInput{ - Name: "bastion", - ProjectID: testSDKProjectID, - Region: testSDKRegion, - NetworkID: testSDKNetworkID, - ImageID: testSDKImageID, - MachineType: "c2i.1", - SSHKeyName: "default", - AllowedCIDRs: []string{"203.0.113.0/24"}, - Tags: map[string]string{"cluster": "test"}, - }); err != nil { - t.Fatalf("EnsureBastion() error = %v", err) - } - - if len(createdRuleCIDRs) != 1 || createdRuleCIDRs[0] != "203.0.113.0/24" { - t.Fatalf("created rules for %v, want [203.0.113.0/24]", createdRuleCIDRs) - } - if len(deletedRuleIDs) != 1 || deletedRuleIDs[0] != staleRuleID { - t.Fatalf("deleted rules %v, want [%s] — the revoked CIDR keeps its SSH access", deletedRuleIDs, staleRuleID) - } -} - -// TestSDKClientEnsureBastionDeduplicatesRepeatedCIDRs guards against a CIDR -// listed twice producing two identical rules: existingRules is a snapshot taken -// before the loop, so the second pass would not see the rule the first pass -// created and the duplicate create fails the whole reconcile. -func TestSDKClientEnsureBastionDeduplicatesRepeatedCIDRs(t *testing.T) { - var createdRuleCIDRs []string - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - path := r.URL.Path - switch { - case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): - writeJSON(t, w, map[string]any{"items": []any{ - map[string]any{ - "id": testSDKSecurityGroup, "name": "bastion-ssh", - "labels": map[string]any{"cluster": "test"}, - }, - }}) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/rules"): - writeJSON(t, w, map[string]any{"items": []any{}}) - case r.Method == http.MethodPost && strings.HasSuffix(path, "/rules"): - payload := readJSON(t, r) - if cidr, ok := payload["ipRange"].(string); ok { - createdRuleCIDRs = append(createdRuleCIDRs, cidr) - } - writeJSON(t, w, map[string]any{"id": "77777777-7777-4777-8777-777777777777", "direction": "ingress"}) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/servers"): - writeJSON(t, w, map[string]any{"items": []any{ - map[string]any{ - "id": testSDKServerID, "name": "bastion", "status": "ACTIVE", "machineType": "c2i.1", - "labels": map[string]any{"cluster": "test"}, - }, - }}) - case strings.Contains(path, "/security-groups/") && strings.Contains(path, "/servers/"): - w.WriteHeader(http.StatusNoContent) - case r.Method == http.MethodGet && strings.HasSuffix(path, "/public-ips"): - writeJSON(t, w, map[string]any{"items": []any{ - map[string]any{ - "id": "66666666-6666-4666-8666-666666666666", "ip": "203.0.113.10", "networkInterface": "nic-1", - "labels": map[string]any{"cluster": "test"}, - }, - }}) - case r.Method == http.MethodGet && strings.Contains(path, "/servers/"): - writeJSON(t, w, map[string]any{ - "id": testSDKServerID, "name": "bastion", "status": "ACTIVE", "machineType": "c2i.1", - }) - default: - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) - } - })) - - client := newTestSDKClient(t, server.URL) - if _, err := client.EnsureBastion(context.Background(), BastionInput{ - Name: "bastion", - ProjectID: testSDKProjectID, - Region: testSDKRegion, - NetworkID: testSDKNetworkID, - ImageID: testSDKImageID, - MachineType: "c2i.1", - SSHKeyName: "default", - // The same CIDR twice, plus a distinct one. - AllowedCIDRs: []string{"203.0.113.0/24", "203.0.113.0/24", "198.51.100.0/24"}, - Tags: map[string]string{"cluster": "test"}, - }); err != nil { - t.Fatalf("EnsureBastion() error = %v", err) - } - - if len(createdRuleCIDRs) != 2 { - t.Fatalf("created %d rules (%v), want 2 — the repeated CIDR was created twice", - len(createdRuleCIDRs), createdRuleCIDRs) - } -} - -func TestSDKClientListAvailabilityZones(t *testing.T) { - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/availability-zones") { - writeJSON(t, w, map[string]any{ - "items": []any{"eu01-1", "eu01-2", "eu01-3"}, - }) - return - } - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) - })) - - client := newTestSDKClient(t, server.URL) - zones, err := client.ListAvailabilityZones(context.Background()) - if err != nil { - t.Fatalf("ListAvailabilityZones() error = %v", err) - } - if len(zones) != 3 || zones[0] != "eu01-1" || zones[1] != "eu01-2" || zones[2] != "eu01-3" { - t.Fatalf("ListAvailabilityZones() = %v, want [eu01-1 eu01-2 eu01-3]", zones) - } -} - -func TestSDKClientCreateAndDeleteNetwork(t *testing.T) { - var createdPayload map[string]any - deletedNetworkID := "" - - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/networks") { - writeJSON(t, w, map[string]any{ - "items": []any{}, - }) - return + t.Run("creates SDKClient when STACKIT_NO_AUTH is true", func(t *testing.T) { + t.Setenv(stackitNoAuthEnv, testBoolTrue) + client, err := NewClient(context.Background(), Credentials{ + ProjectID: testSDKProjectID, + Region: testSDKRegion, + }) + if err != nil { + t.Fatalf("NewClient() error = %v", err) } - if r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/networks") { - createdPayload = readJSON(t, r) - writeJSON(t, w, map[string]any{ - "id": testSDKNetworkID, - "name": "test-network", - "status": "CREATED", - "ipv4": map[string]any{ - "prefixes": []any{"10.0.0.0/24"}, - }, - }) - return + if client.ProjectID() != testSDKProjectID || client.Region() != testSDKRegion { + t.Fatalf("client ProjectID=%q Region=%q", client.ProjectID(), client.Region()) } - if r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/networks/"+testSDKNetworkID) { - deletedNetworkID = testSDKNetworkID - w.WriteHeader(http.StatusNoContent) - return + if client.IaaSClient() == nil || client.LoadBalancerClient() == nil { + t.Fatal("expected non-nil IaaSClient and LoadBalancerClient") } - t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) - })) - - client := newTestSDKClient(t, server.URL) - net, err := client.CreateNetwork(context.Background(), CreateNetworkInput{ - Name: "test-network", - IPv4Prefix: "10.0.0.0/24", - Tags: map[string]string{"cluster": "test-cluster"}, - }) - if err != nil { - t.Fatalf("CreateNetwork() error = %v", err) - } - if net.ID != testSDKNetworkID { - t.Errorf("CreateNetwork() ID = %s, want %s", net.ID, testSDKNetworkID) - } - if createdPayload["name"] != "test-network" { - t.Errorf("CreateNetwork() payload name = %v, want test-network", createdPayload["name"]) - } - - if err := client.DeleteNetwork(context.Background(), testSDKNetworkID); err != nil { - t.Fatalf("DeleteNetwork() error = %v", err) - } - if deletedNetworkID != testSDKNetworkID { - t.Errorf("DeleteNetwork() deleted = %s, want %s", deletedNetworkID, testSDKNetworkID) - } -} - -func TestSDKClientCreateNetworkIdempotent(t *testing.T) { - server := newSDKTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/networks") { - writeJSON(t, w, map[string]any{ - "items": []any{ - map[string]any{ - "id": testSDKNetworkID, - "name": "existing-network", - "status": "CREATED", - "labels": map[string]any{ - "cluster": "test-cluster", - }, - "ipv4": map[string]any{ - "prefixes": []any{"10.0.0.0/24"}, - }, - }, - }, - }) - return - } - t.Fatalf("unexpected request: %s %s (should not create new network when existing matches)", r.Method, r.URL.String()) - })) - - client := newTestSDKClient(t, server.URL) - net, err := client.CreateNetwork(context.Background(), CreateNetworkInput{ - Name: "existing-network", - IPv4Prefix: "10.0.0.0/24", - Tags: map[string]string{"cluster": "test-cluster"}, }) - if err != nil { - t.Fatalf("CreateNetwork() error = %v", err) - } - if net.ID != testSDKNetworkID { - t.Errorf("CreateNetwork() ID = %s, want %s", net.ID, testSDKNetworkID) - } } diff --git a/cloud/services/availabilityzone/reconcile.go b/cloud/services/availabilityzone/reconcile.go new file mode 100644 index 0000000..d14b7d7 --- /dev/null +++ b/cloud/services/availabilityzone/reconcile.go @@ -0,0 +1,49 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package availabilityzone + +import ( + "context" + "fmt" + + logf "sigs.k8s.io/controller-runtime/pkg/log" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +func (s *Service) Reconcile(ctx context.Context) error { + log := logf.FromContext(ctx) + zones, err := s.list(ctx) + if err != nil { + return err + } + spec := s.scope.AvailabilityZoneSpec() + if spec.SetZones != nil { + spec.SetZones(zones) + } + log.V(1).Info("Reconciled availability zones", "count", len(zones)) + return nil +} + +// list retrieves the availability zones for the configured region. +func (s *Service) list(ctx context.Context) ([]string, error) { + if s.scope.Region() == "" { + return nil, fmt.Errorf("%w: region is empty", shared.ErrInvalidInput) + } + resp, err := s.scope.IaaSClient().DefaultAPI.ListAvailabilityZones(ctx, s.scope.Region()).Execute() + if err != nil { + return nil, shared.ClassifySDKError("list availability zones", err) + } + if resp == nil || resp.Items == nil { + return nil, nil + } + return resp.GetItems(), nil +} diff --git a/cloud/services/availabilityzone/reconcile_test.go b/cloud/services/availabilityzone/reconcile_test.go new file mode 100644 index 0000000..89ab47c --- /dev/null +++ b/cloud/services/availabilityzone/reconcile_test.go @@ -0,0 +1,127 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package availabilityzone_test + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "net/http/httptest" + "slices" + "strings" + "testing" + + "github.com/stackitcloud/stackit-sdk-go/core/config" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/availabilityzone" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +const testRegion = "eu01" + +type testScope struct { + projectID string + region string + iaasClient *iaas.APIClient + spec availabilityzone.AvailabilityZoneSpec +} + +func (s *testScope) ProjectID() string { + return s.projectID +} + +func (s *testScope) Region() string { + return s.region +} + +func (s *testScope) IaaSClient() *iaas.APIClient { + return s.iaasClient +} + +func (s *testScope) AvailabilityZoneSpec() availabilityzone.AvailabilityZoneSpec { + return s.spec +} + +func newTestIaaSClient(t *testing.T, handler http.Handler) *iaas.APIClient { + t.Helper() + + srv := httptest.NewServer(handler) + t.Cleanup(srv.Close) + + iaasClient, err := iaas.NewAPIClient( + config.WithoutAuthentication(), + config.WithEndpoint(srv.URL), + ) + if err != nil { + t.Fatalf("iaas.NewAPIClient() error = %v", err) + } + return iaasClient +} + +func newTestService(t *testing.T, spec availabilityzone.AvailabilityZoneSpec, handler http.Handler) *availabilityzone.Service { + t.Helper() + + return availabilityzone.New(&testScope{ + region: testRegion, + iaasClient: newTestIaaSClient(t, handler), + spec: spec, + }) +} + +func writeJSON(t *testing.T, w http.ResponseWriter, value any) { + t.Helper() + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(value); err != nil { + t.Fatalf("encode response body: %v", err) + } +} + +func TestServiceReconcile(t *testing.T) { + t.Run("lists availability zones and passes them to SetZones", func(t *testing.T) { + var recorded []string + spec := availabilityzone.AvailabilityZoneSpec{ + SetZones: func(zones []string) { + recorded = zones + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/availability-zones") { + writeJSON(t, w, map[string]any{ + "items": []string{"eu01-1", "eu01-2", "eu01-3"}, + }) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if !slices.Equal(recorded, []string{"eu01-1", "eu01-2", "eu01-3"}) { + t.Fatalf("recorded = %v, want [eu01-1 eu01-2 eu01-3]", recorded) + } + }) + + t.Run("returns classified error when API fails", func(t *testing.T) { + svc := newTestService(t, availabilityzone.AvailabilityZoneSpec{}, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusInternalServerError) + writeJSON(t, w, map[string]any{"message": "backend error"}) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrTransient) { + t.Fatalf("Reconcile() error = %v, want ErrTransient", err) + } + }) +} diff --git a/cloud/services/availabilityzone/service.go b/cloud/services/availabilityzone/service.go new file mode 100644 index 0000000..f3c0c86 --- /dev/null +++ b/cloud/services/availabilityzone/service.go @@ -0,0 +1,36 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package availabilityzone + +import "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" + +// AvailabilityZoneSpec describes the callback used to record discovered availability zones. +type AvailabilityZoneSpec struct { + SetZones func(zones []string) +} + +// Scope is an interface that provides scope data needed for availability zone reconciliation. +type Scope interface { + shared.IaaSClientScope + AvailabilityZoneSpec() AvailabilityZoneSpec +} + +// Service implements availability zones reconciler. +type Service struct { + scope Scope +} + +// New returns Service from given scope. +func New(scope Scope) *Service { + return &Service{ + scope: scope, + } +} diff --git a/cloud/services/bastion/bastion.go b/cloud/services/bastion/bastion.go deleted file mode 100644 index fac16ff..0000000 --- a/cloud/services/bastion/bastion.go +++ /dev/null @@ -1,53 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package bastion - -import ( - infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" - "github.com/stackitcloud/cluster-api-provider-stackit/scope" - "github.com/stackitcloud/cluster-api-provider-stackit/util" -) - -func Input(clusterScope *scope.ClusterScope, cloudInit []byte) cloud.BastionInput { - stackitCluster := clusterScope.StackitCluster - deleteOnTermination := true - if stackitCluster.Spec.Bastion.RootVolume.DeleteOnTermination != nil { - deleteOnTermination = *stackitCluster.Spec.Bastion.RootVolume.DeleteOnTermination - } - - tags := util.ClusterTags(stackitCluster.Name, stackitCluster.Namespace, stackitCluster.Spec.AdditionalLabels) - tags[util.LabelResourceRole] = util.ResourceRoleBastion - - return cloud.BastionInput{ - Name: stackitCluster.Name + "-bastion", - ProjectID: stackitCluster.Spec.ProjectID, - Region: stackitCluster.Spec.Region, - NetworkID: clusterScope.NetworkID(), - ImageID: stackitCluster.Spec.Bastion.ImageID, - MachineType: stackitCluster.Spec.Bastion.MachineType, - SSHKeyName: stackitCluster.Spec.Bastion.SSHKeyName, - AllowedCIDRs: stackitCluster.Spec.Bastion.AllowedCIDRs, - Tags: tags, - RootVolume: cloud.RootVolumeInput{ - SizeGiB: stackitCluster.Spec.Bastion.RootVolume.SizeGiB, - PerformanceClass: stackitCluster.Spec.Bastion.RootVolume.PerformanceClass, - DeleteOnTermination: deleteOnTermination, - }, - CloudInit: cloudInit, - } -} - -func NodeSSHAccessTags(stackitCluster *infrav1.StackitCluster) map[string]string { - tags := util.ClusterTags(stackitCluster.Name, stackitCluster.Namespace, stackitCluster.Spec.AdditionalLabels) - tags[util.LabelResourceRole] = util.ResourceRoleNodeSSH - return tags -} diff --git a/cloud/services/loadbalancer/loadbalancer.go b/cloud/services/loadbalancer/loadbalancer.go deleted file mode 100644 index aa321e1..0000000 --- a/cloud/services/loadbalancer/loadbalancer.go +++ /dev/null @@ -1,146 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package loadbalancer - -import ( - "context" - "crypto/sha256" - "encoding/hex" - "fmt" - "slices" - "strings" - - clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" - - infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" - "github.com/stackitcloud/cluster-api-provider-stackit/scope" - "github.com/stackitcloud/cluster-api-provider-stackit/util" -) - -const ( - defaultAPIServerPort int32 = 6443 - - // maxTargetNameLength is the RFC 1123 label length, which STACKIT enforces on - // a target display name. - maxTargetNameLength = 63 - - targetNameDigestLength = 7 -) - -func APIServerTags(stackitCluster *infrav1.StackitCluster) map[string]string { - return util.ClusterTags(stackitCluster.Name, stackitCluster.Namespace, stackitCluster.Spec.AdditionalLabels) -} - -func APIServerInput( - clusterScope *scope.ClusterScope, - targets []cloud.LoadBalancerTargetInput, -) cloud.LoadBalancerInput { - stackitCluster := clusterScope.StackitCluster - return cloud.LoadBalancerInput{ - Name: stackitCluster.Name + "-apiserver", - ProjectID: stackitCluster.Spec.ProjectID, - Region: stackitCluster.Spec.Region, - NetworkID: clusterScope.NetworkID(), - Port: defaultAPIServerPort, - Tags: APIServerTags(stackitCluster), - Targets: targets, - } -} - -// BootstrapTarget seeds a new load balancer; STACKIT rejects an empty pool. -func BootstrapTarget(ip string) cloud.LoadBalancerTargetInput { - return cloud.LoadBalancerTargetInput{ - Name: "capi-bootstrap-placeholder", - IP: ip, - } -} - -// APIServerTargets builds the desired API server target pool, sorted by machine -// name so the pool can be compared without spurious updates. The result is empty -// while no control plane machine has an internal IP yet. -func APIServerTargets(machines []*clusterv1.Machine) []cloud.LoadBalancerTargetInput { - sorted := make([]*clusterv1.Machine, 0, len(machines)) - for _, machine := range machines { - if machine != nil { - sorted = append(sorted, machine) - } - } - slices.SortFunc(sorted, func(a, b *clusterv1.Machine) int { - return strings.Compare(a.Name, b.Name) - }) - - targets := make([]cloud.LoadBalancerTargetInput, 0, len(sorted)) - // A target IP must be unique within the pool, and a replacement machine can - // transiently report the IP of the one it replaces. - seen := make(map[string]struct{}, len(sorted)) - for _, machine := range sorted { - ip := firstInternalIP(machine.Status.Addresses) - if ip == "" { - continue - } - if _, duplicate := seen[ip]; duplicate { - continue - } - seen[ip] = struct{}{} - targets = append(targets, cloud.LoadBalancerTargetInput{Name: targetName(machine.Name), IP: ip}) - } - return targets -} - -// targetName maps a machine name, an RFC 1123 subdomain, onto a STACKIT target -// display name, an RFC 1123 label. A name that already is a label is returned -// unchanged; any other carries a digest so that two machines cannot collapse -// onto one target. -func targetName(machineName string) string { - if len(machineName) <= maxTargetNameLength && !strings.Contains(machineName, ".") { - return machineName - } - - sum := sha256.Sum256([]byte(machineName)) - suffix := "-" + hex.EncodeToString(sum[:])[:targetNameDigestLength] - name := strings.ReplaceAll(machineName, ".", "-") - if len(name) > maxTargetNameLength-len(suffix) { - name = strings.TrimRight(name[:maxTargetNameLength-len(suffix)], "-") - } - return name + suffix -} - -func ResolveID( - ctx context.Context, - cloudClient cloud.Client, - stackitCluster *infrav1.StackitCluster, -) (string, error) { - if stackitCluster.Status.APIServerLoadBalancerID != "" { - return stackitCluster.Status.APIServerLoadBalancerID, nil - } - - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, APIServerTags(stackitCluster)) - if err != nil { - return "", err - } - if len(loadBalancers) == 0 { - return "", nil - } - if len(loadBalancers) > 1 { - return "", fmt.Errorf("multiple API server load balancers match cluster tags: %w", cloud.ErrConflict) - } - return loadBalancers[0].ID, nil -} - -func firstInternalIP(addresses []clusterv1.MachineAddress) string { - for _, address := range addresses { - if address.Type == clusterv1.MachineInternalIP && address.Address != "" { - return address.Address - } - } - return "" -} diff --git a/cloud/services/loadbalancer/reconcile.go b/cloud/services/loadbalancer/reconcile.go new file mode 100644 index 0000000..419a88c --- /dev/null +++ b/cloud/services/loadbalancer/reconcile.go @@ -0,0 +1,235 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package loadbalancer + +import ( + "cmp" + "context" + "fmt" + "strings" + + lb "github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/v2api" + logf "sigs.k8s.io/controller-runtime/pkg/log" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +func (s *Service) Reconcile(ctx context.Context) error { + log := logf.FromContext(ctx) + spec := s.scope.LoadBalancerSpec() + if err := spec.validate(); err != nil { + return err + } + + loadBalancer, created, err := s.ensureLoadBalancer(ctx, spec) + if err != nil { + return err + } + loadBalancer.Port = spec.Port + if spec.SetLoadBalancer != nil { + spec.SetLoadBalancer(loadBalancer, created) + } + if loadBalancer.IP == "" { + return nil + } + + // An empty set never overwrites a populated pool: cluster deletion filters + // out every machine while the API server is still needed for drain. + if len(spec.Targets) > 0 { + if err := s.setTargets(ctx, loadBalancer.ID, spec.Port, spec.Targets); err != nil { + return fmt.Errorf("%w: %w", errTargetPoolUpdate, err) + } + log.V(1).Info("Reconciled API server load balancer target pool", "targets", len(spec.Targets)) + } + log.V(1).Info("Reconciled load balancer resources", "loadBalancerID", loadBalancer.ID, "created", created) + return nil +} + +func (s *Service) Delete(ctx context.Context) error { + log := logf.FromContext(ctx) + spec := s.scope.LoadBalancerSpec() + if spec.ID == "" && len(spec.Tags) == 0 { + return fmt.Errorf("%w: load balancer ID or tags are required", shared.ErrInvalidInput) + } + + deletedIDs, err := shared.DeleteByIDOrTags(ctx, spec.ID, spec.Tags, s.deleteByID, s.listIDsByTags) + for _, deletedID := range deletedIDs { + log.V(1).Info("Deleted load balancer", "loadBalancerID", deletedID) + } + if err != nil { + return err + } + if spec.SetLoadBalancer != nil { + spec.SetLoadBalancer(nil, false) + } + return nil +} + +// get retrieves a STACKIT load balancer by ID. +func (s *Service) get(ctx context.Context, id string) (*LoadBalancer, error) { + if id == "" { + return nil, fmt.Errorf("%w: load balancer ID is empty", shared.ErrInvalidInput) + } + loadBalancer, err := s.scope.LoadBalancerClient().DefaultAPI.GetLoadBalancer(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute() + if err != nil { + return nil, shared.ClassifySDKError("get load balancer", err) + } + return loadBalancerFromSDK(loadBalancer), nil +} + +// findByTags finds a single STACKIT load balancer matching the given tag selector. +func (s *Service) findByTags(ctx context.Context, tags map[string]string) (*LoadBalancer, error) { + return shared.FindByTags(ctx, tags, s.listByTags, "load balancer", "load balancers") +} + +// listByTags lists STACKIT load balancers matching the given tag selector. +func (s *Service) listByTags(ctx context.Context, tags map[string]string) ([]*LoadBalancer, error) { + return shared.ListByTags(Labels(tags), func(_ string) ([]lb.LoadBalancer, error) { + resp, err := s.scope.LoadBalancerClient().DefaultAPI.ListLoadBalancers(ctx, s.scope.ProjectID(), s.scope.Region()).Execute() + if err != nil { + err := shared.ClassifySDKError("list load balancers", err) + if isLoadBalancerServiceNotEnabled(err) { + return nil, nil + } + return nil, err + } + return resp.GetLoadBalancers(), nil + }, loadBalancerFromSDK) +} + +// deleteByID deletes a load balancer by ID, returning true if the load balancer existed and was deleted, +// or false if it was already absent. +func (s *Service) deleteByID(ctx context.Context, id string) (bool, error) { + if id == "" { + return false, fmt.Errorf("%w: load balancer ID is empty", shared.ErrInvalidInput) + } + if _, err := s.scope.LoadBalancerClient().DefaultAPI.DeleteLoadBalancer(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute(); err != nil { + err := shared.ClassifySDKError("delete load balancer", err) + if shared.IsNotFound(err) { + return false, nil + } + return false, err + } + return true, nil +} + +func (s *Service) ensureLoadBalancer(ctx context.Context, spec LoadBalancerSpec) (*LoadBalancer, bool, error) { + loadBalancer, err := shared.ResolveExisting(ctx, spec.ID, spec.Tags, s.get, s.findByTags, isIgnorableLookupError) + if err != nil { + return nil, false, err + } + if loadBalancer != nil { + return loadBalancer, false, nil + } + + payload := spec.toCreatePayload(s.scope.Region()) + lbResp, err := s.scope.LoadBalancerClient().DefaultAPI.CreateLoadBalancer(ctx, s.scope.ProjectID(), s.scope.Region()). + CreateLoadBalancerPayload(payload). + Execute() + if err != nil { + return nil, false, shared.ClassifySDKError("create load balancer", err) + } + out := loadBalancerFromSDK(lbResp) + logf.FromContext(ctx).V(1).Info("Created load balancer", "name", spec.Name, "loadBalancerID", out.ID) + return out, true, nil +} + +func (s *Service) listIDsByTags(ctx context.Context, tags map[string]string) ([]string, error) { + return shared.ListIDsByTags(ctx, tags, s.listByTags, func(loadBalancer *LoadBalancer) string { + return loadBalancer.ID + }) +} + +func (s LoadBalancerSpec) validate() error { + if s.Name == "" { + return fmt.Errorf("%w: load balancer name is required", shared.ErrInvalidInput) + } + if s.NetworkID == "" { + return fmt.Errorf("%w: load balancer network ID is required", shared.ErrInvalidInput) + } + if s.Port <= 0 { + return fmt.Errorf("%w: load balancer port must be positive", shared.ErrInvalidInput) + } + if len(s.Tags) == 0 { + return fmt.Errorf("%w: load balancer tags are required", shared.ErrInvalidInput) + } + return nil +} + +func (s LoadBalancerSpec) toCreatePayload(region string) lb.CreateLoadBalancerPayload { + payload := lb.NewCreateLoadBalancerPayload() + payload.SetName(s.Name) + payload.SetRegion(region) + if len(s.Tags) > 0 { + payload.SetLabels(Labels(s.Tags)) + } + options := lb.NewLoadBalancerOptions() + options.SetEphemeralAddress(true) + payload.SetOptions(*options) + + network := lb.NewNetwork() + network.SetNetworkId(s.NetworkID) + network.SetRole("ROLE_LISTENERS_AND_TARGETS") + payload.SetNetworks([]lb.Network{*network}) + + targetPool := lb.NewTargetPool() + targetPool.SetName(apiserverTargetPoolName) + targetPool.SetTargetPort(s.Port) + seed := s.SeedTargets + if len(seed) == 0 { + seed = s.Targets + } + targets := make([]lb.Target, 0, max(1, len(seed))) + if len(seed) == 0 { + bootstrap := BootstrapTarget("") + target := lb.NewTarget() + target.SetDisplayName(bootstrap.Name) + target.SetIp(bootstrap.IP) + targets = append(targets, *target) + } else { + for _, targetInput := range seed { + target := lb.NewTarget() + target.SetDisplayName(targetInput.Name) + target.SetIp(targetInput.IP) + targets = append(targets, *target) + } + } + targetPool.SetTargets(targets) + payload.SetTargetPools([]lb.TargetPool{*targetPool}) + + listener := lb.NewListener() + listener.SetDisplayName(apiserverListenerName) + listener.SetPort(s.Port) + listener.SetProtocol(listenerProtocolTCP) + listener.SetTargetPool(apiserverTargetPoolName) + payload.SetListeners([]lb.Listener{*listener}) + + return *payload +} + +func loadBalancerFromSDK(in *lb.LoadBalancer) *LoadBalancer { + if in == nil { + return nil + } + return &LoadBalancer{ + ID: in.GetName(), + Name: in.GetName(), + IP: cmp.Or(in.GetExternalAddress(), in.GetPrivateAddress()), + } +} + +func isIgnorableLookupError(err error) bool { + return shared.IsNotFound(err) || isLoadBalancerServiceNotEnabled(err) +} + +func isLoadBalancerServiceNotEnabled(err error) bool { + return shared.IsUnauthorized(err) && strings.Contains(err.Error(), "Service not enabled") +} diff --git a/cloud/services/loadbalancer/reconcile_test.go b/cloud/services/loadbalancer/reconcile_test.go new file mode 100644 index 0000000..8df0b30 --- /dev/null +++ b/cloud/services/loadbalancer/reconcile_test.go @@ -0,0 +1,701 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package loadbalancer_test + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "net/http/httptest" + "strings" + "sync" + "testing" + + "github.com/stackitcloud/stackit-sdk-go/core/config" + lb "github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/v2api" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +const ( + testProjectID = "00000000-0000-0000-0000-000000000000" + testRegion = "eu01" + testNetworkID = "11111111-1111-4111-8111-111111111111" + testLBName = "test-cluster-apiserver" + testPublicIP = "203.0.113.10" +) + +type testScope struct { + projectID string + region string + lbClient *lb.APIClient + spec loadbalancer.LoadBalancerSpec +} + +func (s *testScope) ProjectID() string { + return s.projectID +} + +func (s *testScope) Region() string { + return s.region +} + +func (s *testScope) LoadBalancerClient() *lb.APIClient { + return s.lbClient +} + +func (s *testScope) LoadBalancerSpec() loadbalancer.LoadBalancerSpec { + return s.spec +} + +func newTestLBClient(t *testing.T, handler http.Handler) *lb.APIClient { + t.Helper() + + server := httptest.NewServer(handler) + t.Cleanup(server.Close) + + lbClient, err := lb.NewAPIClient( + config.WithoutAuthentication(), + config.WithEndpoint(server.URL), + ) + if err != nil { + t.Fatalf("lb.NewAPIClient() error = %v", err) + } + return lbClient +} + +func newTestService(t *testing.T, spec loadbalancer.LoadBalancerSpec, handler http.Handler) *loadbalancer.Service { + t.Helper() + + return loadbalancer.New(&testScope{ + projectID: testProjectID, + region: testRegion, + lbClient: newTestLBClient(t, handler), + spec: spec, + }) +} + +func writeJSON(t *testing.T, w http.ResponseWriter, value any) { + t.Helper() + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(value); err != nil { + t.Fatalf("encode response body: %v", err) + } +} + +func readJSON(t *testing.T, r *http.Request) map[string]any { + t.Helper() + var out map[string]any + if err := json.NewDecoder(r.Body).Decode(&out); err != nil { + t.Fatalf("decode request body: %v", err) + } + return out +} + +func sdkLoadBalancerJSON(name string, labels map[string]any, targetPools []any) map[string]any { + m := map[string]any{ + "name": name, + "externalAddress": testPublicIP, + "listeners": []any{ + map[string]any{"displayName": "apiserver", "port": 6443, "targetPool": "apiserver"}, + }, + "targetPools": targetPools, + } + if len(labels) > 0 { + m["labels"] = labels + } + return m +} + +func TestServiceReconcile(t *testing.T) { + t.Run("creates load balancer with expected payload and updates target pool", func(t *testing.T) { + var ( + createPayload map[string]any + recordedID string + recordedIP string + recordedPort int32 + recordedCreated bool + ) + spec := loadbalancer.LoadBalancerSpec{ + Name: testLBName, + NetworkID: testNetworkID, + Port: loadbalancer.DefaultAPIServerPort, + Tags: map[string]string{ + "cluster.x-k8s.io/cluster-name": "test", + "cluster-api-provider-stackit/test-id": "run-1", + }, + Targets: []loadbalancer.Target{ + {Name: "cp-0", IP: "10.0.0.10"}, + }, + SeedTargets: []loadbalancer.Target{ + {Name: "cp-0", IP: "10.0.0.10"}, + }, + SetLoadBalancer: func(apiServerLB *loadbalancer.LoadBalancer, created bool) { + recordedID = apiServerLB.ID + recordedIP = apiServerLB.IP + recordedPort = apiServerLB.Port + recordedCreated = created + }, + } + + targetPool := []any{ + map[string]any{ + "name": "apiserver", + "targetPort": 6443, + "targets": []any{ + map[string]any{"displayName": "cp-0", "ip": "10.0.0.10"}, + }, + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers"): + writeJSON(t, w, map[string]any{"loadBalancers": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/load-balancers"): + createPayload = readJSON(t, r) + writeJSON(t, w, sdkLoadBalancerJSON(testLBName, nil, targetPool)) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers/"+testLBName): + writeJSON(t, w, sdkLoadBalancerJSON(testLBName, nil, targetPool)) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + + if recordedID != testLBName { + t.Fatalf("recordedID = %q, want %q", recordedID, testLBName) + } + if recordedIP != testPublicIP || recordedPort != 6443 { + t.Fatalf("recorded address = %s:%d, want %s:6443", recordedIP, recordedPort, testPublicIP) + } + if !recordedCreated { + t.Fatal("recordedCreated = false, want true") + } + if createPayload["name"] != testLBName { + t.Fatalf("payload name = %v, want %q", createPayload["name"], testLBName) + } + if createPayload["region"] != testRegion { + t.Fatalf("payload region = %v, want %q", createPayload["region"], testRegion) + } + labels, _ := createPayload["labels"].(map[string]any) + if labels["cluster.x-k8s.io.cluster-name"] != "test" || labels["cluster-api-provider-stackit.test-id"] != "run-1" { + t.Fatalf("payload labels = %#v", labels) + } + }) + + t.Run("uses bootstrap placeholder target when initial targets are empty", func(t *testing.T) { + var createPayload map[string]any + spec := loadbalancer.LoadBalancerSpec{ + Name: testLBName, + NetworkID: testNetworkID, + Port: loadbalancer.DefaultAPIServerPort, + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers"): + writeJSON(t, w, map[string]any{"loadBalancers": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/load-balancers"): + createPayload = readJSON(t, r) + writeJSON(t, w, sdkLoadBalancerJSON(testLBName, nil, []any{ + map[string]any{ + "name": "apiserver", + "targetPort": 6443, + "targets": []any{ + map[string]any{"displayName": "capi-bootstrap-placeholder", "ip": "10.0.0.1"}, + }, + }, + })) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + + pools, _ := createPayload["targetPools"].([]any) + if len(pools) != 1 { + t.Fatalf("targetPools = %#v, want 1 pool", pools) + } + pool, _ := pools[0].(map[string]any) + targets, _ := pool["targets"].([]any) + if len(targets) != 1 { + t.Fatalf("targets = %#v, want 1 target", targets) + } + target, _ := targets[0].(map[string]any) + if target["displayName"] != "capi-bootstrap-placeholder" || target["ip"] != "10.0.0.1" { + t.Fatalf("target = %#v, want placeholder", target) + } + }) +} + +func TestServiceReconcileReuseAndErrors(t *testing.T) { + t.Run("reuses existing load balancer found by ID without listing by tags", func(t *testing.T) { + var ( + recordedID string + recordedCreated = true + ) + spec := loadbalancer.LoadBalancerSpec{ + ID: testLBName, + Name: testLBName, + NetworkID: testNetworkID, + Port: loadbalancer.DefaultAPIServerPort, + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + SetLoadBalancer: func(apiServerLB *loadbalancer.LoadBalancer, created bool) { + recordedID = apiServerLB.ID + recordedCreated = created + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/load-balancers/"+testLBName) { + writeJSON(t, w, sdkLoadBalancerJSON(testLBName, nil, nil)) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if recordedID != testLBName { + t.Fatalf("recordedID = %q, want %q", recordedID, testLBName) + } + if recordedCreated { + t.Fatal("recordedCreated = true on reused load balancer, want false") + } + }) + + t.Run("falls back to tag lookup when recorded ID is not found during reconcile", func(t *testing.T) { + var ( + getByIDCalled bool + recordedID string + ) + spec := loadbalancer.LoadBalancerSpec{ + ID: "stale-lb", + Name: testLBName, + NetworkID: testNetworkID, + Port: loadbalancer.DefaultAPIServerPort, + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + SetLoadBalancer: func(apiServerLB *loadbalancer.LoadBalancer, _ bool) { + recordedID = apiServerLB.ID + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers/stale-lb"): + getByIDCalled = true + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers"): + writeJSON(t, w, map[string]any{"loadBalancers": []any{ + sdkLoadBalancerJSON(testLBName, map[string]any{ + "cluster.x-k8s.io.cluster-name": "test", + }, nil), + }}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if !getByIDCalled { + t.Fatal("expected GET by spec.ID before falling back to tag lookup") + } + if recordedID != testLBName { + t.Fatalf("recordedID = %q, want %q", recordedID, testLBName) + } + }) + + t.Run("reuses existing load balancer found by tags without creating duplicate", func(t *testing.T) { + var recordedID string + spec := loadbalancer.LoadBalancerSpec{ + Name: testLBName, + NetworkID: testNetworkID, + Port: loadbalancer.DefaultAPIServerPort, + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + SetLoadBalancer: func(apiServerLB *loadbalancer.LoadBalancer, _ bool) { + recordedID = apiServerLB.ID + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/load-balancers") { + writeJSON(t, w, map[string]any{"loadBalancers": []any{ + sdkLoadBalancerJSON(testLBName, map[string]any{ + "cluster.x-k8s.io.cluster-name": "test", + }, nil), + }}) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if recordedID != testLBName { + t.Fatalf("recordedID = %q, want %q", recordedID, testLBName) + } + }) + + t.Run("returns ErrConflict when multiple load balancers match tags", func(t *testing.T) { + spec := loadbalancer.LoadBalancerSpec{ + Name: testLBName, + NetworkID: testNetworkID, + Port: loadbalancer.DefaultAPIServerPort, + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + writeJSON(t, w, map[string]any{"loadBalancers": []any{ + sdkLoadBalancerJSON("lb-1", map[string]any{"cluster.x-k8s.io.cluster-name": "test"}, nil), + sdkLoadBalancerJSON("lb-2", map[string]any{"cluster.x-k8s.io.cluster-name": "test"}, nil), + }}) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrConflict) { + t.Fatalf("Reconcile() error = %v, want ErrConflict", err) + } + }) + + t.Run("wraps target pool update failures in ErrTargetPoolUpdate after setting ID and address", func(t *testing.T) { + var ( + recordedID string + recordedIP string + ) + spec := loadbalancer.LoadBalancerSpec{ + Name: testLBName, + NetworkID: testNetworkID, + Port: loadbalancer.DefaultAPIServerPort, + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + Targets: []loadbalancer.Target{{Name: "cp-0", IP: "10.0.0.10"}}, + SetLoadBalancer: func(apiServerLB *loadbalancer.LoadBalancer, _ bool) { + recordedID = apiServerLB.ID + recordedIP = apiServerLB.IP + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers"): + writeJSON(t, w, map[string]any{"loadBalancers": []any{ + sdkLoadBalancerJSON(testLBName, map[string]any{ + "cluster.x-k8s.io.cluster-name": "test", + }, nil), + }}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers/"+testLBName): + w.WriteHeader(http.StatusInternalServerError) + writeJSON(t, w, map[string]any{"message": "backend error"}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + err := svc.Reconcile(context.Background()) + if !loadbalancer.IsTargetPoolUpdateError(err) { + t.Fatalf("Reconcile() error = %v, want IsTargetPoolUpdateError", err) + } + if !shared.IsTransient(err) { + t.Fatalf("Reconcile() error = %v, want wrapped ErrTransient", err) + } + if recordedID != testLBName || recordedIP != testPublicIP { + t.Fatalf("recordedID=%q recordedIP=%q, want both set before target error", recordedID, recordedIP) + } + }) +} + +func TestSetTargets(t *testing.T) { + var mu sync.Mutex + targets := []any{ + map[string]any{"displayName": "cp-0", "ip": "10.0.0.10"}, + } + var updatePayloads []map[string]any + + scope := &testScope{ + projectID: testProjectID, + region: testRegion, + lbClient: newTestLBClient(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + mu.Lock() + defer mu.Unlock() + + switch { + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/load-balancers/"+testLBName): + writeJSON(t, w, sdkLoadBalancerJSON(testLBName, nil, []any{ + map[string]any{"name": "apiserver", "targetPort": 6443, "targets": targets}, + })) + case r.Method == http.MethodPut && strings.HasSuffix(r.URL.Path, "/load-balancers/"+testLBName+"/target-pools/apiserver"): + payload := readJSON(t, r) + updatePayloads = append(updatePayloads, payload) + next, ok := payload["targets"].([]any) + if !ok { + t.Fatalf("update target payload missing targets: %#v", payload) + } + targets = next + writeJSON(t, w, map[string]any{ + "name": "apiserver", + "targetPort": 6443, + "targets": targets, + }) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })), + spec: loadbalancer.LoadBalancerSpec{ + ID: testLBName, + Name: testLBName, + NetworkID: testNetworkID, + Port: 6443, + Tags: map[string]string{"cluster": "test"}, + }, + } + svc := loadbalancer.New(scope) + + desired := []loadbalancer.Target{ + {Name: "cp-0", IP: "10.0.0.10"}, + {Name: "cp-1", IP: "10.0.0.11"}, + } + scope.spec.Targets = desired + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if len(updatePayloads) != 1 { + t.Fatalf("got %d update payloads, want 1", len(updatePayloads)) + } + + // Unchanged pool must not trigger another write. + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() repeat error = %v", err) + } + if len(updatePayloads) != 1 { + t.Fatalf("got %d update payloads after unchanged set, want 1", len(updatePayloads)) + } + + // Shrinking pool updates targets. + scope.spec.Targets = desired[:1] + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() shrink error = %v", err) + } + if len(updatePayloads) != 2 { + t.Fatalf("got %d update payloads, want 2", len(updatePayloads)) + } + + // Target missing name or IP is rejected. + scope.spec.Targets = []loadbalancer.Target{{Name: "", IP: "10.0.0.10"}} + if err := svc.Reconcile(context.Background()); !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Reconcile(invalid target) error = %v, want ErrInvalidInput", err) + } +} + +func TestServiceReconcileValidation(t *testing.T) { + tests := []struct { + name string + spec loadbalancer.LoadBalancerSpec + }{ + { + name: "missing name", + spec: loadbalancer.LoadBalancerSpec{ + NetworkID: testNetworkID, + Port: 6443, + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "missing network ID", + spec: loadbalancer.LoadBalancerSpec{ + Name: testLBName, + Port: 6443, + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "invalid port", + spec: loadbalancer.LoadBalancerSpec{ + Name: testLBName, + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "missing tags", + spec: loadbalancer.LoadBalancerSpec{ + Name: testLBName, + NetworkID: testNetworkID, + Port: 6443, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + svc := newTestService(t, tt.spec, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Reconcile() error = %v, want ErrInvalidInput", err) + } + }) + } +} + +func TestServiceDelete(t *testing.T) { + t.Run("deletes load balancer using ID when provided and clears state", func(t *testing.T) { + var ( + deletedID string + clearedLB = &loadbalancer.LoadBalancer{ID: "not-cleared"} + clearedCreated = true + ) + spec := loadbalancer.LoadBalancerSpec{ + ID: testLBName, + SetLoadBalancer: func(apiServerLB *loadbalancer.LoadBalancer, created bool) { + clearedLB = apiServerLB + clearedCreated = created + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/load-balancers/"+testLBName) { + deletedID = testLBName + writeJSON(t, w, map[string]any{}) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if deletedID != testLBName { + t.Fatalf("deletedID = %q, want %q", deletedID, testLBName) + } + if clearedLB != nil || clearedCreated { + t.Fatalf("cleared state = (%#v, %v), want (nil, false)", clearedLB, clearedCreated) + } + }) + + t.Run("falls back to tag lookup when ID is empty and deletes all matching load balancers", func(t *testing.T) { + var deletedIDs []string + spec := loadbalancer.LoadBalancerSpec{ + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers"): + writeJSON(t, w, map[string]any{"loadBalancers": []any{ + sdkLoadBalancerJSON(testLBName, map[string]any{ + "cluster.x-k8s.io.cluster-name": "test", + }, nil), + sdkLoadBalancerJSON("second-lb", map[string]any{ + "cluster.x-k8s.io.cluster-name": "test", + }, nil), + sdkLoadBalancerJSON("other-lb", map[string]any{ + "cluster.x-k8s.io.cluster-name": "other", + }, nil), + }}) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/load-balancers/"+testLBName): + deletedIDs = append(deletedIDs, testLBName) + writeJSON(t, w, map[string]any{}) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/load-balancers/second-lb"): + deletedIDs = append(deletedIDs, "second-lb") + writeJSON(t, w, map[string]any{}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if len(deletedIDs) != 2 || deletedIDs[0] != testLBName || deletedIDs[1] != "second-lb" { + t.Fatalf("deletedIDs = %v, want [%s second-lb]", deletedIDs, testLBName) + } + }) + + t.Run("falls back to tag lookup when recorded ID no longer exists", func(t *testing.T) { + var deletedID string + spec := loadbalancer.LoadBalancerSpec{ + ID: "stale-lb", + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/load-balancers/stale-lb"): + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/load-balancers"): + writeJSON(t, w, map[string]any{"loadBalancers": []any{ + sdkLoadBalancerJSON(testLBName, map[string]any{ + "cluster.x-k8s.io.cluster-name": "test", + }, nil), + }}) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/load-balancers/"+testLBName): + deletedID = testLBName + writeJSON(t, w, map[string]any{}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if deletedID != testLBName { + t.Fatalf("deletedID = %q, want %q", deletedID, testLBName) + } + }) + + t.Run("succeeds when load balancer does not exist", func(t *testing.T) { + spec := loadbalancer.LoadBalancerSpec{ + Tags: map[string]string{"cluster.x-k8s.io/cluster-name": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + writeJSON(t, w, map[string]any{"loadBalancers": []any{}}) + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v, want nil", err) + } + }) + + t.Run("returns ErrInvalidInput when both ID and tags are empty", func(t *testing.T) { + svc := newTestService(t, loadbalancer.LoadBalancerSpec{}, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Delete(context.Background()); !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Delete() error = %v, want ErrInvalidInput", err) + } + }) +} diff --git a/cloud/services/loadbalancer/service.go b/cloud/services/loadbalancer/service.go new file mode 100644 index 0000000..1f12001 --- /dev/null +++ b/cloud/services/loadbalancer/service.go @@ -0,0 +1,84 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package loadbalancer + +import ( + "errors" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +const ( + // DefaultAPIServerPort is the default TCP port for the Kubernetes API server. + DefaultAPIServerPort int32 = 6443 + + // DefaultBootstrapTargetIP is the fallback IPv4 address used for the + // bootstrap placeholder target when no network prefix can be derived. + DefaultBootstrapTargetIP = "10.0.0.1" + + apiserverTargetPoolName = "apiserver" + apiserverListenerName = "apiserver" + bootstrapTargetName = "capi-bootstrap-placeholder" + listenerProtocolTCP = "PROTOCOL_TCP" +) + +// errTargetPoolUpdate indicates that the load balancer was created/resolved +// successfully, but updating its target pool failed. +var errTargetPoolUpdate = errors.New("load balancer target pool update failed") + +// IsTargetPoolUpdateError reports whether err wraps errTargetPoolUpdate. +func IsTargetPoolUpdateError(err error) bool { + return errors.Is(err, errTargetPoolUpdate) +} + +// LoadBalancer describes an API-server load balancer. +type LoadBalancer struct { + ID string + Name string + IP string + Port int32 +} + +// Target describes a VM target in the API-server load balancer target pool. +type Target struct { + Name string + IP string +} + +// LoadBalancerSpec describes the desired state of a STACKIT API server load balancer. +type LoadBalancerSpec struct { + ID string + Name string + NetworkID string + Port int32 + Tags map[string]string + Targets []Target + SeedTargets []Target + SetLoadBalancer func(loadBalancer *LoadBalancer, created bool) +} + +// Scope is an interface that provides scope data needed for load balancer reconciliation. +type Scope interface { + shared.LoadBalancerClientScope + LoadBalancerSpec() LoadBalancerSpec +} + +// Service implements load balancer reconciler. +type Service struct { + scope Scope +} + +// New returns Service from given scope. +func New(scope Scope) *Service { + return &Service{ + scope: scope, + } +} diff --git a/cloud/services/loadbalancer/targets.go b/cloud/services/loadbalancer/targets.go new file mode 100644 index 0000000..19b0d57 --- /dev/null +++ b/cloud/services/loadbalancer/targets.go @@ -0,0 +1,211 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package loadbalancer + +import ( + "cmp" + "context" + "crypto/sha256" + "encoding/hex" + "fmt" + "slices" + "strings" + + lb "github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/v2api" + clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +const ( + // maxTargetNameLength is the RFC 1123 label length, which STACKIT enforces on + // a target display name. + maxTargetNameLength = 63 + + targetNameDigestLength = 7 +) + +// BootstrapTarget seeds a new load balancer; STACKIT rejects an empty pool. +func BootstrapTarget(ip string) Target { + if ip == "" { + ip = DefaultBootstrapTargetIP + } + return Target{ + Name: bootstrapTargetName, + IP: ip, + } +} + +// APIServerTargets builds the desired API server target pool, sorted by machine +// name so the pool can be compared without spurious updates. The result is empty +// while no control plane machine has an internal IP yet. +func APIServerTargets(machines []*clusterv1.Machine) []Target { + sorted := make([]*clusterv1.Machine, 0, len(machines)) + for _, machine := range machines { + if machine != nil { + sorted = append(sorted, machine) + } + } + slices.SortFunc(sorted, func(a, b *clusterv1.Machine) int { + return strings.Compare(a.Name, b.Name) + }) + + targets := make([]Target, 0, len(sorted)) + // A target IP must be unique within the pool, and a replacement machine can + // transiently report the IP of the one it replaces. + seen := make(map[string]struct{}, len(sorted)) + for _, machine := range sorted { + ip := firstInternalIP(machine.Status.Addresses) + if ip == "" { + continue + } + if _, duplicate := seen[ip]; duplicate { + continue + } + seen[ip] = struct{}{} + targets = append(targets, Target{Name: targetName(machine.Name), IP: ip}) + } + return targets +} + +// Labels converts tag keys containing "/" into "." to satisfy STACKIT Load Balancer label rules. +func Labels(tags map[string]string) map[string]string { + out := make(map[string]string, len(tags)) + for k, v := range tags { + out[strings.ReplaceAll(k, "/", ".")] = v + } + return out +} + +// targetName maps a machine name, an RFC 1123 subdomain, onto a STACKIT target +// display name, an RFC 1123 label. A name that already is a label is returned +// unchanged; any other carries a digest so that two machines cannot collapse +// onto one target. +func targetName(machineName string) string { + if len(machineName) <= maxTargetNameLength && !strings.Contains(machineName, ".") { + return machineName + } + + sum := sha256.Sum256([]byte(machineName)) + suffix := "-" + hex.EncodeToString(sum[:])[:targetNameDigestLength] + name := strings.ReplaceAll(machineName, ".", "-") + if len(name) > maxTargetNameLength-len(suffix) { + name = strings.TrimRight(name[:maxTargetNameLength-len(suffix)], "-") + } + return name + suffix +} + +func firstInternalIP(addresses []clusterv1.MachineAddress) string { + for _, address := range addresses { + if address.Type == clusterv1.MachineInternalIP && address.Address != "" { + return address.Address + } + } + return "" +} + +// setTargets replaces the contents of the API-server target pool. STACKIT rejects an empty pool. +func (s *Service) setTargets( + ctx context.Context, + loadBalancerID string, + port int32, + targets []Target, +) error { + if loadBalancerID == "" || port <= 0 { + return fmt.Errorf("%w: load balancer ID and target port are required", shared.ErrInvalidInput) + } + // STACKIT NLB target pools must contain at least one target. + if len(targets) == 0 { + return fmt.Errorf("%w: at least one target is required", shared.ErrInvalidInput) + } + desired := make([]lb.Target, 0, len(targets)) + for _, targetInput := range targets { + if targetInput.Name == "" || targetInput.IP == "" { + return fmt.Errorf("%w: target name and target IP are required", shared.ErrInvalidInput) + } + target := lb.NewTarget() + target.SetDisplayName(targetInput.Name) + target.SetIp(targetInput.IP) + desired = append(desired, *target) + } + + loadBalancer, err := s.scope.LoadBalancerClient().DefaultAPI.GetLoadBalancer(ctx, s.scope.ProjectID(), s.scope.Region(), loadBalancerID).Execute() + if err != nil { + return shared.ClassifySDKError("get load balancer", err) + } + targetPool := apiServerTargetPool(loadBalancer) + if targetPool == nil { + return fmt.Errorf( + "%w: load balancer %q has no %q target pool", + shared.ErrNotFound, + loadBalancerID, + apiserverTargetPoolName, + ) + } + + // Every cluster reconcile ends up here; skip the update call when the pool + // already matches. + if targetPool.GetTargetPort() == port && sameTargets(targetPool.GetTargets(), desired) { + return nil + } + return s.updateAPIServerTargetPool(ctx, loadBalancerID, desired, port) +} + +func (s *Service) updateAPIServerTargetPool( + ctx context.Context, + loadBalancerID string, + targets []lb.Target, + port int32, +) error { + payload := lb.NewUpdateTargetPoolPayload() + payload.SetName(apiserverTargetPoolName) + payload.SetTargetPort(port) + payload.SetTargets(targets) + if _, err := s.scope.LoadBalancerClient().DefaultAPI. + UpdateTargetPool(ctx, s.scope.ProjectID(), s.scope.Region(), loadBalancerID, apiserverTargetPoolName). + UpdateTargetPoolPayload(*payload). + Execute(); err != nil { + return shared.ClassifySDKError("update load balancer target pool", err) + } + return nil +} + +func apiServerTargetPool(loadBalancer *lb.LoadBalancer) *lb.TargetPool { + if loadBalancer == nil { + return nil + } + for _, targetPool := range loadBalancer.GetTargetPools() { + if targetPool.GetName() == apiserverTargetPoolName { + return &targetPool + } + } + return nil +} + +func sameTargets(current, desired []lb.Target) bool { + if len(current) != len(desired) { + return false + } + return slices.Equal(sortedTargetKeys(current), sortedTargetKeys(desired)) +} + +type targetKey struct{ name, ip string } + +func sortedTargetKeys(targets []lb.Target) []targetKey { + keys := make([]targetKey, 0, len(targets)) + for _, target := range targets { + keys = append(keys, targetKey{name: target.GetDisplayName(), ip: target.GetIp()}) + } + slices.SortFunc(keys, func(a, b targetKey) int { + return cmp.Or(strings.Compare(a.name, b.name), strings.Compare(a.ip, b.ip)) + }) + return keys +} diff --git a/cloud/services/loadbalancer/loadbalancer_test.go b/cloud/services/loadbalancer/targets_test.go similarity index 92% rename from cloud/services/loadbalancer/loadbalancer_test.go rename to cloud/services/loadbalancer/targets_test.go index 8e02fe5..839ae13 100644 --- a/cloud/services/loadbalancer/loadbalancer_test.go +++ b/cloud/services/loadbalancer/targets_test.go @@ -19,8 +19,6 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" - - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" ) func machineWithAddresses(name string, addresses ...clusterv1.MachineAddress) *clusterv1.Machine { @@ -38,7 +36,7 @@ func TestAPIServerTargets(t *testing.T) { tests := []struct { name string machines []*clusterv1.Machine - want []cloud.LoadBalancerTargetInput + want []Target }{ { name: "sorts targets by machine name", @@ -47,7 +45,7 @@ func TestAPIServerTargets(t *testing.T) { machineWithAddresses("cp-0", internalIP("10.0.0.10")), machineWithAddresses("cp-1", internalIP("10.0.0.11")), }, - want: []cloud.LoadBalancerTargetInput{ + want: []Target{ {Name: "cp-0", IP: "10.0.0.10"}, {Name: "cp-1", IP: "10.0.0.11"}, {Name: "cp-2", IP: "10.0.0.12"}, @@ -63,7 +61,7 @@ func TestAPIServerTargets(t *testing.T) { Address: "203.0.113.10", }), }, - want: []cloud.LoadBalancerTargetInput{{Name: "cp-0", IP: "10.0.0.10"}}, + want: []Target{{Name: "cp-0", IP: "10.0.0.10"}}, }, { name: "drops a duplicate IP address", @@ -71,7 +69,7 @@ func TestAPIServerTargets(t *testing.T) { machineWithAddresses("cp-1", internalIP("10.0.0.10")), machineWithAddresses("cp-0", internalIP("10.0.0.10")), }, - want: []cloud.LoadBalancerTargetInput{{Name: "cp-0", IP: "10.0.0.10"}}, + want: []Target{{Name: "cp-0", IP: "10.0.0.10"}}, }, { // The placeholder belongs to the creation path, not here. @@ -82,7 +80,7 @@ func TestAPIServerTargets(t *testing.T) { { name: "tolerates nil entries", machines: []*clusterv1.Machine{nil, machineWithAddresses("cp-0", internalIP("10.0.0.11"))}, - want: []cloud.LoadBalancerTargetInput{{Name: "cp-0", IP: "10.0.0.11"}}, + want: []Target{{Name: "cp-0", IP: "10.0.0.11"}}, }, } diff --git a/cloud/services/network/network.go b/cloud/services/network/network.go deleted file mode 100644 index 50b5633..0000000 --- a/cloud/services/network/network.go +++ /dev/null @@ -1,64 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package network - -import ( - "context" - - infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" - "github.com/stackitcloud/cluster-api-provider-stackit/util" -) - -const ( - // DefaultNetworkPrefix defines the default CIDR allocated for a managed cluster network. - DefaultNetworkPrefix = "10.0.0.0/24" -) - -func NetworkTags(stackitCluster *infrav1.StackitCluster) map[string]string { - return util.ClusterTags(stackitCluster.Name, stackitCluster.Namespace, stackitCluster.Spec.AdditionalLabels) -} - -func Input(stackitCluster *infrav1.StackitCluster) cloud.CreateNetworkInput { - return cloud.CreateNetworkInput{ - Name: stackitCluster.Name + "-network", - IPv4Prefix: DefaultNetworkPrefix, - Tags: NetworkTags(stackitCluster), - } -} - -// ResolveManagedNetworkID finds the managed network ID to delete during cluster teardown. -// It returns empty string if the cluster is in BYO mode or if no managed network is found. -// Neither spec nor status is a trustworthy record of what exists in the cloud, so if status -// was lost, it falls back to looking up the network by cluster tags. -func ResolveManagedNetworkID( - ctx context.Context, - cloudClient cloud.Client, - stackitCluster *infrav1.StackitCluster, -) (string, error) { - // If spec.network.id is set, the network is BYO and must NEVER be deleted. - if stackitCluster.Spec.Network.ID != "" { - return "", nil - } - - if stackitCluster.Status.Network.ID != "" { - return stackitCluster.Status.Network.ID, nil - } - - network, err := cloudClient.FindNetworkByTags(ctx, NetworkTags(stackitCluster)) - if err != nil { - if cloud.IsNotFound(err) { - return "", nil - } - return "", err - } - return network.ID, nil -} diff --git a/cloud/services/network/network_test.go b/cloud/services/network/network_test.go deleted file mode 100644 index 015b9f5..0000000 --- a/cloud/services/network/network_test.go +++ /dev/null @@ -1,134 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package network - -import ( - "context" - "testing" - - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" - cloudfake "github.com/stackitcloud/cluster-api-provider-stackit/cloud/fake" - "github.com/stackitcloud/cluster-api-provider-stackit/util" -) - -func TestNetworkInput(t *testing.T) { - cluster := &infrav1.StackitCluster{ - ObjectMeta: metav1.ObjectMeta{ - Name: "test-cluster", - Namespace: "test-ns", - }, - Spec: infrav1.StackitClusterSpec{ - AdditionalLabels: map[string]string{ - "custom-label": "custom-value", - }, - }, - } - - input := Input(cluster) - - if input.Name != "test-cluster-network" { - t.Errorf("Input() Name = %s, want test-cluster-network", input.Name) - } - if input.IPv4Prefix != DefaultNetworkPrefix { - t.Errorf("Input() IPv4Prefix = %s, want %s", input.IPv4Prefix, DefaultNetworkPrefix) - } - if input.Tags[util.LabelClusterName] != "test-cluster" { - t.Errorf("Input() missing cluster-name tag") - } - if input.Tags[util.LabelClusterNamespace] != "test-ns" { - t.Errorf("Input() missing cluster-namespace tag") - } - if input.Tags[util.LabelManagedBy] != util.ManagedByValue { - t.Errorf("Input() missing managed-by tag") - } - if input.Tags["custom-label"] != "custom-value" { - t.Errorf("Input() missing merged additional label") - } -} - -func TestResolveManagedNetworkID(t *testing.T) { - ctx := context.Background() - - t.Run("returns empty string for BYO network in spec", func(t *testing.T) { - fakeClient := cloudfake.New() - cluster := &infrav1.StackitCluster{ - ObjectMeta: metav1.ObjectMeta{Name: "byo-cluster", Namespace: "default"}, - Spec: infrav1.StackitClusterSpec{ - Network: infrav1.StackitClusterNetworkSpec{ID: "byo-net-id"}, - }, - Status: infrav1.StackitClusterStatus{ - Network: infrav1.StackitNetworkStatus{ID: "byo-net-id", Managed: false}, - }, - } - - id, err := ResolveManagedNetworkID(ctx, fakeClient, cluster) - if err != nil { - t.Fatalf("ResolveManagedNetworkID() error = %v", err) - } - if id != "" { - t.Errorf("ResolveManagedNetworkID() = %q, want empty string for BYO network", id) - } - }) - - t.Run("returns network ID from status when present", func(t *testing.T) { - fakeClient := cloudfake.New() - cluster := &infrav1.StackitCluster{ - ObjectMeta: metav1.ObjectMeta{Name: "managed-cluster", Namespace: "default"}, - Status: infrav1.StackitClusterStatus{ - Network: infrav1.StackitNetworkStatus{ID: "status-net-id", Managed: true}, - }, - } - - id, err := ResolveManagedNetworkID(ctx, fakeClient, cluster) - if err != nil { - t.Fatalf("ResolveManagedNetworkID() error = %v", err) - } - if id != "status-net-id" { - t.Errorf("ResolveManagedNetworkID() = %q, want status-net-id", id) - } - }) - - t.Run("falls back to tag lookup when status is empty", func(t *testing.T) { - fakeClient := cloudfake.New() - cluster := &infrav1.StackitCluster{ - ObjectMeta: metav1.ObjectMeta{Name: "managed-cluster", Namespace: "default"}, - } - created, err := fakeClient.CreateNetwork(ctx, Input(cluster)) - if err != nil { - t.Fatalf("CreateNetwork() error = %v", err) - } - - id, err := ResolveManagedNetworkID(ctx, fakeClient, cluster) - if err != nil { - t.Fatalf("ResolveManagedNetworkID() error = %v", err) - } - if id != created.ID { - t.Errorf("ResolveManagedNetworkID() = %q, want %q", id, created.ID) - } - }) - - t.Run("returns empty string when no network exists in status or cloud", func(t *testing.T) { - fakeClient := cloudfake.New() - cluster := &infrav1.StackitCluster{ - ObjectMeta: metav1.ObjectMeta{Name: "managed-cluster", Namespace: "default"}, - } - - id, err := ResolveManagedNetworkID(ctx, fakeClient, cluster) - if err != nil { - t.Fatalf("ResolveManagedNetworkID() error = %v", err) - } - if id != "" { - t.Errorf("ResolveManagedNetworkID() = %q, want empty string", id) - } - }) -} diff --git a/cloud/services/network/reconcile.go b/cloud/services/network/reconcile.go new file mode 100644 index 0000000..208dca5 --- /dev/null +++ b/cloud/services/network/reconcile.go @@ -0,0 +1,193 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package network + +import ( + "context" + "fmt" + + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + logf "sigs.k8s.io/controller-runtime/pkg/log" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +func (s *Service) Reconcile(ctx context.Context) error { + log := logf.FromContext(ctx) + spec := s.scope.NetworkSpec() + if err := spec.validate(); err != nil { + return err + } + + var ( + net *Network + created bool + err error + ) + if spec.Managed { + net, created, err = s.ensureNetwork(ctx, spec) + } else { + net, err = s.get(ctx, spec.ID) + } + if err != nil { + return err + } + if spec.SetNetwork != nil { + spec.SetNetwork(net, created) + } + log.V(1).Info("Reconciled network resources", "networkID", net.ID, "created", created) + return nil +} + +func (s *Service) Delete(ctx context.Context) error { + log := logf.FromContext(ctx) + spec := s.scope.NetworkSpec() + if !spec.Managed { + return nil + } + if spec.ID == "" && len(spec.Tags) == 0 { + return fmt.Errorf("%w: network ID or tags are required", shared.ErrInvalidInput) + } + + deletedIDs, err := shared.DeleteByIDOrTags(ctx, spec.ID, spec.Tags, s.deleteByID, s.listIDsByTags) + for _, deletedID := range deletedIDs { + log.V(1).Info("Deleted network", "networkID", deletedID) + } + if err != nil { + return err + } + if spec.SetNetwork != nil { + spec.SetNetwork(nil, false) + } + return nil +} + +// get retrieves a STACKIT network by ID. +func (s *Service) get(ctx context.Context, id string) (*Network, error) { + if id == "" { + return nil, fmt.Errorf("%w: network ID is empty", shared.ErrInvalidInput) + } + net, err := s.scope.IaaSClient().DefaultAPI.GetNetwork(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute() + if err != nil { + return nil, shared.ClassifySDKError("get network", err) + } + return networkFromSDK(net), nil +} + +// findByTags finds a single STACKIT network matching the given tag selector. +func (s *Service) findByTags(ctx context.Context, tags map[string]string) (*Network, error) { + return shared.FindByTags(ctx, tags, s.listByTags, "network", "networks") +} + +// listByTags lists STACKIT networks matching the given tag selector. +func (s *Service) listByTags(ctx context.Context, tags map[string]string) ([]*Network, error) { + return shared.ListByTags(tags, func(selector string) ([]iaas.Network, error) { + resp, err := s.scope.IaaSClient().DefaultAPI.ListNetworks(ctx, s.scope.ProjectID(), s.scope.Region()). + LabelSelector(selector). + Execute() + if err != nil { + return nil, shared.ClassifySDKError("list networks", err) + } + return resp.GetItems(), nil + }, networkFromSDK) +} + +func (s *Service) listIDsByTags(ctx context.Context, tags map[string]string) ([]string, error) { + return shared.ListIDsByTags(ctx, tags, s.listByTags, func(net *Network) string { + return net.ID + }) +} + +// deleteByID deletes a network by ID, returning true if the network existed and was deleted, +// or false if it was already absent. +func (s *Service) deleteByID(ctx context.Context, id string) (bool, error) { + if id == "" { + return false, fmt.Errorf("%w: network ID is empty", shared.ErrInvalidInput) + } + if err := s.scope.IaaSClient().DefaultAPI.DeleteNetwork(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute(); err != nil { + err := shared.ClassifySDKError("delete network", err) + if shared.IsNotFound(err) { + return false, nil + } + return false, err + } + return true, nil +} + +// create creates a new STACKIT network from the given spec. +func (s *Service) create(ctx context.Context, spec NetworkSpec) (*Network, error) { + payload := spec.toCreatePayload() + created, err := s.scope.IaaSClient().DefaultAPI.CreateNetwork(ctx, s.scope.ProjectID(), s.scope.Region()). + CreateNetworkPayload(payload). + Execute() + if err != nil { + return nil, shared.ClassifySDKError("create network", err) + } + out := networkFromSDK(created) + logf.FromContext(ctx).V(1).Info("Created network", "name", spec.Name, "networkID", out.ID) + return out, nil +} + +func (s *Service) ensureNetwork(ctx context.Context, spec NetworkSpec) (*Network, bool, error) { + net, err := shared.ResolveExisting(ctx, spec.ID, spec.Tags, s.get, s.findByTags, shared.IsNotFound) + if err != nil { + return nil, false, err + } + if net != nil { + return net, false, nil + } + + out, err := s.create(ctx, spec) + if err != nil { + return nil, false, err + } + return out, true, nil +} + +func (s NetworkSpec) validate() error { + if s.Managed { + if s.Name == "" { + return fmt.Errorf("%w: network name is required", shared.ErrInvalidInput) + } + if len(s.Tags) == 0 { + return fmt.Errorf("%w: network tags are required", shared.ErrInvalidInput) + } + return nil + } + if s.ID == "" { + return fmt.Errorf("%w: network ID is required", shared.ErrInvalidInput) + } + return nil +} + +func (s NetworkSpec) toCreatePayload() iaas.CreateNetworkPayload { + payload := iaas.NewCreateNetworkPayload(s.Name) + if len(s.Tags) > 0 { + payload.SetLabels(shared.TagsToSDKLabels(s.Tags)) + } + if s.IPv4Prefix != "" { + ipv4Payload := iaas.NewCreateNetworkIPv4WithPrefix(s.IPv4Prefix) + payload.SetIpv4(iaas.CreateNetworkIPv4WithPrefixAsCreateNetworkIPv4(ipv4Payload)) + } + return *payload +} + +func networkFromSDK(net *iaas.Network) *Network { + if net == nil { + return nil + } + ipv4 := net.GetIpv4() + return &Network{ + ID: net.GetId(), + Name: net.GetName(), + IPv4Prefixes: ipv4.GetPrefixes(), + } +} diff --git a/cloud/services/network/reconcile_test.go b/cloud/services/network/reconcile_test.go new file mode 100644 index 0000000..1b84efb --- /dev/null +++ b/cloud/services/network/reconcile_test.go @@ -0,0 +1,354 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package network_test + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "net/http/httptest" + "slices" + "strings" + "testing" + + "github.com/stackitcloud/stackit-sdk-go/core/config" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +const ( + testProjectID = "00000000-0000-0000-0000-000000000000" + testRegion = "eu01" + testNetworkID = "11111111-1111-4111-8111-111111111111" +) + +type testScope struct { + projectID string + region string + iaasClient *iaas.APIClient + spec network.NetworkSpec +} + +func (s *testScope) ProjectID() string { + return s.projectID +} + +func (s *testScope) Region() string { + return s.region +} + +func (s *testScope) IaaSClient() *iaas.APIClient { + return s.iaasClient +} + +func (s *testScope) NetworkSpec() network.NetworkSpec { + return s.spec +} + +func newTestIaaSClient(t *testing.T, handler http.Handler) *iaas.APIClient { + t.Helper() + + srv := httptest.NewServer(handler) + t.Cleanup(srv.Close) + + iaasClient, err := iaas.NewAPIClient( + config.WithoutAuthentication(), + config.WithEndpoint(srv.URL), + ) + if err != nil { + t.Fatalf("iaas.NewAPIClient() error = %v", err) + } + return iaasClient +} + +func newTestService(t *testing.T, spec network.NetworkSpec, handler http.Handler) *network.Service { + t.Helper() + + return network.New(&testScope{ + projectID: testProjectID, + region: testRegion, + iaasClient: newTestIaaSClient(t, handler), + spec: spec, + }) +} + +func writeJSON(t *testing.T, w http.ResponseWriter, value any) { + t.Helper() + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(value); err != nil { + t.Fatalf("encode response body: %v", err) + } +} + +func TestServiceReconcile(t *testing.T) { + t.Run("fetches network and records IPv4 prefixes via SetNetwork", func(t *testing.T) { + var ( + recorded *network.Network + created bool + ) + spec := network.NetworkSpec{ + ID: testNetworkID, + SetNetwork: func(n *network.Network, c bool) { + recorded = n + created = c + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/networks/"+testNetworkID) { + writeJSON(t, w, map[string]any{ + "id": testNetworkID, + "name": "cluster-net", + "status": "CREATED", + "routed": true, + "ipv4": map[string]any{ + "prefixes": []string{"10.20.0.0/24"}, + }, + }) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if recorded == nil || recorded.ID != testNetworkID || recorded.Name != "cluster-net" { + t.Fatalf("recorded = %#v, want ID=%s Name=cluster-net", recorded, testNetworkID) + } + if created { + t.Fatal("created = true, want false for unmanaged network") + } + if !slices.Equal(recorded.IPv4Prefixes, []string{"10.20.0.0/24"}) { + t.Fatalf("recorded.IPv4Prefixes = %v, want [10.20.0.0/24]", recorded.IPv4Prefixes) + } + }) + + t.Run("returns ErrNotFound when network does not exist", func(t *testing.T) { + spec := network.NetworkSpec{ + ID: testNetworkID, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrNotFound) { + t.Fatalf("Reconcile() error = %v, want ErrNotFound", err) + } + }) + + t.Run("returns ErrInvalidInput when network ID is empty for unmanaged network", func(t *testing.T) { + svc := newTestService(t, network.NetworkSpec{}, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Reconcile() error = %v, want ErrInvalidInput", err) + } + }) + + t.Run("creates managed network when none exists", func(t *testing.T) { + var ( + recorded *network.Network + created bool + createdPayload map[string]any + ) + spec := network.NetworkSpec{ + Name: "test-network", + IPv4Prefix: network.DefaultNetworkPrefix, + Tags: map[string]string{"cluster": "test-cluster"}, + Managed: true, + SetNetwork: func(n *network.Network, c bool) { + recorded = n + created = c + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/networks") { + writeJSON(t, w, map[string]any{"items": []any{}}) + return + } + if r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/networks") { + if err := json.NewDecoder(r.Body).Decode(&createdPayload); err != nil { + t.Fatalf("decode payload: %v", err) + } + writeJSON(t, w, map[string]any{ + "id": testNetworkID, + "name": "test-network", + "status": "CREATED", + "ipv4": map[string]any{ + "prefixes": []any{"10.0.0.0/24"}, + }, + }) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if recorded == nil || recorded.ID != testNetworkID { + t.Fatalf("recorded = %#v, want ID=%s", recorded, testNetworkID) + } + if !created { + t.Fatal("created = false, want true") + } + if createdPayload["name"] != "test-network" { + t.Fatalf("payload name = %v, want test-network", createdPayload["name"]) + } + }) + + t.Run("adopts existing managed network by tags without creating duplicate", func(t *testing.T) { + var ( + recorded *network.Network + created bool + ) + spec := network.NetworkSpec{ + Name: "existing-network", + IPv4Prefix: network.DefaultNetworkPrefix, + Tags: map[string]string{"cluster": "test-cluster"}, + Managed: true, + SetNetwork: func(n *network.Network, c bool) { + recorded = n + created = c + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/networks") { + writeJSON(t, w, map[string]any{ + "items": []any{ + map[string]any{ + "id": testNetworkID, + "name": "existing-network", + "status": "CREATED", + "labels": map[string]any{ + "cluster": "test-cluster", + }, + "ipv4": map[string]any{ + "prefixes": []any{"10.0.0.0/24"}, + }, + }, + }, + }) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if recorded == nil || recorded.ID != testNetworkID { + t.Fatalf("recorded = %#v, want ID=%s", recorded, testNetworkID) + } + if created { + t.Fatal("created = true, want false when adopting existing network") + } + }) +} + +func TestServiceDelete(t *testing.T) { + t.Run("does not delete unmanaged network", func(t *testing.T) { + spec := network.NetworkSpec{ + ID: testNetworkID, + Managed: false, + } + svc := newTestService(t, spec, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + }) + + t.Run("deletes managed network by ID and clears via SetNetwork", func(t *testing.T) { + deletedID := "" + cleared := false + spec := network.NetworkSpec{ + ID: testNetworkID, + Tags: map[string]string{"cluster": "test-cluster"}, + Managed: true, + SetNetwork: func(n *network.Network, _ bool) { + if n == nil { + cleared = true + } + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/networks/"+testNetworkID) { + deletedID = testNetworkID + w.WriteHeader(http.StatusNoContent) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if deletedID != testNetworkID { + t.Fatalf("deletedID = %s, want %s", deletedID, testNetworkID) + } + if !cleared { + t.Fatal("expected SetNetwork(nil, false) to be called") + } + }) + + t.Run("falls back to tag lookup when ID is empty on Delete", func(t *testing.T) { + deletedID := "" + spec := network.NetworkSpec{ + Tags: map[string]string{"cluster": "test-cluster"}, + Managed: true, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/networks") { + writeJSON(t, w, map[string]any{ + "items": []any{ + map[string]any{ + "id": testNetworkID, + "name": "managed-network", + "status": "CREATED", + "labels": map[string]any{ + "cluster": "test-cluster", + }, + }, + }, + }) + return + } + if r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/networks/"+testNetworkID) { + deletedID = testNetworkID + w.WriteHeader(http.StatusNoContent) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if deletedID != testNetworkID { + t.Fatalf("deletedID = %s, want %s", deletedID, testNetworkID) + } + }) +} diff --git a/cloud/services/network/service.go b/cloud/services/network/service.go new file mode 100644 index 0000000..ac49f78 --- /dev/null +++ b/cloud/services/network/service.go @@ -0,0 +1,51 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package network + +import "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" + +// DefaultNetworkPrefix is the default IPv4 CIDR block used when creating a managed network. +const DefaultNetworkPrefix = "10.0.0.0/24" + +// Network describes a STACKIT virtual network. +type Network struct { + ID string + Name string + IPv4Prefixes []string +} + +// NetworkSpec describes the desired state of a STACKIT network. +type NetworkSpec struct { + ID string + Name string + IPv4Prefix string + Tags map[string]string + Managed bool + SetNetwork func(network *Network, created bool) +} + +// Scope is an interface that provides scope data needed for network reconciliation. +type Scope interface { + shared.IaaSClientScope + NetworkSpec() NetworkSpec +} + +// Service implements network reconciler. +type Service struct { + scope Scope +} + +// New returns Service from given scope. +func New(scope Scope) *Service { + return &Service{ + scope: scope, + } +} diff --git a/cloud/services/publicip/reconcile.go b/cloud/services/publicip/reconcile.go new file mode 100644 index 0000000..d3ee05c --- /dev/null +++ b/cloud/services/publicip/reconcile.go @@ -0,0 +1,239 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package publicip + +import ( + "context" + "fmt" + + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + logf "sigs.k8s.io/controller-runtime/pkg/log" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +func (s *Service) Reconcile(ctx context.Context) error { + log := logf.FromContext(ctx) + spec := s.scope.PublicIPSpec() + if err := spec.validate(); err != nil { + return err + } + + publicIP, err := s.ensurePublicIP(ctx, spec) + if err != nil { + return err + } + + if spec.ServerID != "" && publicIP.NetworkInterfaceID == "" { + if err := s.attachToServer(ctx, spec.ServerID, publicIP.ID); err != nil { + return err + } + publicIP, err = s.get(ctx, publicIP.ID) + if err != nil { + return err + } + } + + if spec.SetPublicIP != nil { + spec.SetPublicIP(publicIP) + } + log.V(1).Info("Reconciled public IP resources", "publicIPID", publicIP.ID) + return nil +} + +func (s *Service) Delete(ctx context.Context) error { + log := logf.FromContext(ctx) + spec := s.scope.PublicIPSpec() + if spec.ID == "" && len(spec.Tags) == 0 { + return fmt.Errorf("%w: public IP ID or tags are required", shared.ErrInvalidInput) + } + + serverIDs, err := s.resolveServerIDs(ctx, spec) + if err != nil { + return err + } + deletedIDs, err := shared.DeleteByIDOrTags(ctx, spec.ID, spec.Tags, func(ctx context.Context, id string) (bool, error) { + return s.detachAndDeleteByID(ctx, id, serverIDs) + }, s.listIDsByTags) + for _, deletedID := range deletedIDs { + log.V(1).Info("Deleted public IP", "publicIPID", deletedID) + } + if err != nil { + return err + } + + if spec.SetPublicIP != nil { + spec.SetPublicIP(nil) + } + return nil +} + +// get retrieves a STACKIT public IP by ID. +func (s *Service) get(ctx context.Context, id string) (*PublicIP, error) { + if id == "" { + return nil, fmt.Errorf("%w: public IP ID is empty", shared.ErrInvalidInput) + } + publicIP, err := s.scope.IaaSClient().DefaultAPI.GetPublicIP(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute() + if err != nil { + return nil, shared.ClassifySDKError("get public IP", err) + } + return publicIPFromSDK(publicIP), nil +} + +// findByTags finds a single STACKIT public IP matching the given tag selector. +func (s *Service) findByTags(ctx context.Context, tags map[string]string) (*PublicIP, error) { + return shared.FindByTags(ctx, tags, s.listByTags, "public IP", "public IPs") +} + +// listByTags lists STACKIT public IPs matching the given tag selector. +func (s *Service) listByTags(ctx context.Context, tags map[string]string) ([]*PublicIP, error) { + return shared.ListByTags(tags, func(selector string) ([]iaas.PublicIp, error) { + resp, err := s.scope.IaaSClient().DefaultAPI.ListPublicIPs(ctx, s.scope.ProjectID(), s.scope.Region()). + LabelSelector(selector). + Execute() + if err != nil { + return nil, shared.ClassifySDKError("list public IPs", err) + } + return resp.GetItems(), nil + }, publicIPFromSDK) +} + +// attachToServer attaches a public IP to a server idempotently, tolerating Conflict errors. +func (s *Service) attachToServer(ctx context.Context, serverID, publicIPID string) error { + if serverID == "" || publicIPID == "" { + return fmt.Errorf("%w: server ID and public IP ID are required", shared.ErrInvalidInput) + } + if err := s.scope.IaaSClient().DefaultAPI. + AddPublicIpToServer(ctx, s.scope.ProjectID(), s.scope.Region(), serverID, publicIPID). + Execute(); err != nil { + err := shared.ClassifySDKError("add public IP to server", err) + if !shared.IsConflict(err) { + return err + } + logf.FromContext(ctx).V(1).Info("Public IP already attached to server", "publicIPID", publicIPID, "serverID", serverID, "err", err) + return nil + } + logf.FromContext(ctx).V(1).Info("Attached public IP to server", "publicIPID", publicIPID, "serverID", serverID) + return nil +} + +// detachFromServer detaches a public IP from a server, ignoring NotFound and Conflict errors. +func (s *Service) detachFromServer(ctx context.Context, serverID, publicIPID string) error { + if serverID == "" || publicIPID == "" { + return fmt.Errorf("%w: server ID and public IP ID are required", shared.ErrInvalidInput) + } + if err := s.scope.IaaSClient().DefaultAPI. + RemovePublicIpFromServer(ctx, s.scope.ProjectID(), s.scope.Region(), serverID, publicIPID). + Execute(); err != nil { + err := shared.ClassifySDKError("remove public IP from server", err) + if !shared.IsNotFound(err) && !shared.IsConflict(err) { + return err + } + logf.FromContext(ctx).V(1).Info("Public IP already detached from server", "publicIPID", publicIPID, "serverID", serverID, "err", err) + return nil + } + logf.FromContext(ctx).V(1).Info("Detached public IP from server", "publicIPID", publicIPID, "serverID", serverID) + return nil +} + +// deleteByID deletes a public IP by ID, returning true if the public IP existed and was deleted, +// or false if it was already absent. +func (s *Service) deleteByID(ctx context.Context, id string) (bool, error) { + if id == "" { + return false, fmt.Errorf("%w: public IP ID is empty", shared.ErrInvalidInput) + } + if err := s.scope.IaaSClient().DefaultAPI.DeletePublicIP(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute(); err != nil { + err := shared.ClassifySDKError("delete public IP", err) + if shared.IsNotFound(err) { + return false, nil + } + return false, err + } + return true, nil +} + +func (s *Service) detachAndDeleteByID(ctx context.Context, id string, serverIDs []string) (bool, error) { + for _, serverID := range serverIDs { + if err := s.detachFromServer(ctx, serverID, id); err != nil { + return false, err + } + } + return s.deleteByID(ctx, id) +} + +func (s *Service) listIDsByTags(ctx context.Context, tags map[string]string) ([]string, error) { + return shared.ListIDsByTags(ctx, tags, s.listByTags, func(publicIP *PublicIP) string { + return publicIP.ID + }) +} + +func (s *Service) ensurePublicIP(ctx context.Context, spec PublicIPSpec) (*PublicIP, error) { + publicIP, err := shared.ResolveExisting(ctx, spec.ID, spec.Tags, s.get, s.findByTags, shared.IsNotFound) + if err != nil { + return nil, err + } + if publicIP != nil { + return publicIP, nil + } + + payload := iaas.NewCreatePublicIPPayload() + if len(spec.Tags) > 0 { + payload.SetLabels(shared.TagsToSDKLabels(spec.Tags)) + } + created, err := s.scope.IaaSClient().DefaultAPI. + CreatePublicIP(ctx, s.scope.ProjectID(), s.scope.Region()). + CreatePublicIPPayload(*payload). + Execute() + if err != nil { + return nil, shared.ClassifySDKError("create public IP", err) + } + out := publicIPFromSDK(created) + logf.FromContext(ctx).V(1).Info("Created public IP", "publicIPID", out.ID) + return out, nil +} + +func (s *Service) resolveServerIDs(ctx context.Context, spec PublicIPSpec) ([]string, error) { + var ids []string + if spec.ServerID != "" { + ids = append(ids, spec.ServerID) + } + if len(spec.ServerSelector) == 0 { + return ids, nil + } + selectedIDs, err := shared.ListServerIDsByTags(ctx, s.scope, spec.ServerSelector) + if err != nil { + return nil, err + } + for _, id := range selectedIDs { + if id != spec.ServerID { + ids = append(ids, id) + } + } + return ids, nil +} + +func (s PublicIPSpec) validate() error { + if len(s.Tags) == 0 { + return fmt.Errorf("%w: public IP tags are required", shared.ErrInvalidInput) + } + return nil +} + +func publicIPFromSDK(in *iaas.PublicIp) *PublicIP { + if in == nil { + return nil + } + return &PublicIP{ + ID: in.GetId(), + IP: in.GetIp(), + NetworkInterfaceID: in.GetNetworkInterface(), + } +} diff --git a/cloud/services/publicip/reconcile_test.go b/cloud/services/publicip/reconcile_test.go new file mode 100644 index 0000000..78af6ac --- /dev/null +++ b/cloud/services/publicip/reconcile_test.go @@ -0,0 +1,487 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package publicip_test + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/go-logr/logr" + "github.com/go-logr/logr/funcr" + "github.com/stackitcloud/stackit-sdk-go/core/config" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + logf "sigs.k8s.io/controller-runtime/pkg/log" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/publicip" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +const ( + testProjectID = "00000000-0000-0000-0000-000000000000" + testRegion = "eu01" + testPublicIPID = "11111111-1111-4111-8111-111111111111" + testOtherPublicIPID = "22222222-2222-4222-8222-222222222222" + testMissingPublicIP = "99999999-9999-4999-8999-999999999999" + testServerID = "33333333-3333-4333-8333-333333333333" + testNetworkInterface = "[VISA_REDACTED]-8444-444444444444" + testPublicIPAddress = "203.0.113.22" +) + +type testScope struct { + projectID string + region string + iaasClient *iaas.APIClient + spec publicip.PublicIPSpec +} + +func (s *testScope) ProjectID() string { + return s.projectID +} + +func (s *testScope) Region() string { + return s.region +} + +func (s *testScope) IaaSClient() *iaas.APIClient { + return s.iaasClient +} + +func (s *testScope) PublicIPSpec() publicip.PublicIPSpec { + return s.spec +} + +func newTestIaaSClient(t *testing.T, handler http.Handler) *iaas.APIClient { + t.Helper() + + srv := httptest.NewServer(handler) + t.Cleanup(srv.Close) + + iaasClient, err := iaas.NewAPIClient( + config.WithoutAuthentication(), + config.WithEndpoint(srv.URL), + ) + if err != nil { + t.Fatalf("iaas.NewAPIClient() error = %v", err) + } + return iaasClient +} + +func newTestService(t *testing.T, spec publicip.PublicIPSpec, handler http.Handler) *publicip.Service { + t.Helper() + + return publicip.New(&testScope{ + projectID: testProjectID, + region: testRegion, + iaasClient: newTestIaaSClient(t, handler), + spec: spec, + }) +} + +func writeJSON(t *testing.T, w http.ResponseWriter, value any) { + t.Helper() + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(value); err != nil { + t.Fatalf("encode response body: %v", err) + } +} + +func readJSON(t *testing.T, r *http.Request) map[string]any { + t.Helper() + var out map[string]any + if err := json.NewDecoder(r.Body).Decode(&out); err != nil { + t.Fatalf("decode request body: %v", err) + } + return out +} + +func contextWithLogCapture(logs *[]string) context.Context { + logger := funcr.New(func(_, args string) { + *logs = append(*logs, args) + }, funcr.Options{Verbosity: 1}) + return logf.IntoContext(context.Background(), logr.New(logger.GetSink())) +} + +func TestServiceReconcile(t *testing.T) { + t.Run("creates public IP and attaches it to server when not found", func(t *testing.T) { + var ( + createPayload map[string]any + attachedPair string + recorded *publicip.PublicIP + ) + spec := publicip.PublicIPSpec{ + Tags: map[string]string{"cluster": "test"}, + ServerID: testServerID, + SetPublicIP: func(pip *publicip.PublicIP) { + recorded = pip + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/public-ips"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/public-ips"): + createPayload = readJSON(t, r) + writeJSON(t, w, map[string]any{ + "id": testPublicIPID, + "ip": testPublicIPAddress, + }) + case r.Method == http.MethodPut && strings.HasSuffix(path, "/servers/"+testServerID+"/public-ips/"+testPublicIPID): + attachedPair = testServerID + ":" + testPublicIPID + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/public-ips/"+testPublicIPID): + writeJSON(t, w, map[string]any{ + "id": testPublicIPID, + "ip": testPublicIPAddress, + "networkInterface": testNetworkInterface, + }) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if attachedPair != testServerID+":"+testPublicIPID { + t.Fatalf("attachedPair = %q, want %s:%s", attachedPair, testServerID, testPublicIPID) + } + if recorded == nil || recorded.ID != testPublicIPID || recorded.IP != testPublicIPAddress { + t.Fatalf("recorded = %#v, want ID=%q IP=%q", recorded, testPublicIPID, testPublicIPAddress) + } + labels, _ := createPayload["labels"].(map[string]any) + if labels["cluster"] != "test" { + t.Fatalf("createPayload labels = %#v, want cluster=test", labels) + } + }) + + t.Run("reuses existing public IP found by ID without listing by tags", func(t *testing.T) { + var recorded *publicip.PublicIP + spec := publicip.PublicIPSpec{ + ID: testPublicIPID, + Tags: map[string]string{"cluster": "test"}, + ServerID: testServerID, + SetPublicIP: func(pip *publicip.PublicIP) { + recorded = pip + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/public-ips/"+testPublicIPID) { + writeJSON(t, w, map[string]any{ + "id": testPublicIPID, + "ip": testPublicIPAddress, + "networkInterface": testNetworkInterface, + }) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if recorded == nil || recorded.ID != testPublicIPID || recorded.IP != testPublicIPAddress { + t.Fatalf("recorded = %#v, want ID=%q IP=%q", recorded, testPublicIPID, testPublicIPAddress) + } + }) +} + +func TestServiceReconcileReuseAndErrors(t *testing.T) { + t.Run("reuses existing public IP found by tags without creating duplicate", func(t *testing.T) { + var recordedID string + spec := publicip.PublicIPSpec{ + Tags: map[string]string{"cluster": "test"}, + SetPublicIP: func(pip *publicip.PublicIP) { + recordedID = pip.ID + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/public-ips") { + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testPublicIPID, + "ip": testPublicIPAddress, + "labels": map[string]any{"cluster": "test"}, + }, + }}) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if recordedID != testPublicIPID { + t.Fatalf("recordedID = %q, want %q", recordedID, testPublicIPID) + } + }) + + t.Run("tolerates conflict when attaching public IP to server", func(t *testing.T) { + var ( + recordedID string + logs []string + ) + spec := publicip.PublicIPSpec{ + ID: testPublicIPID, + Tags: map[string]string{"cluster": "test"}, + ServerID: testServerID, + SetPublicIP: func(pip *publicip.PublicIP) { + recordedID = pip.ID + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/public-ips/"+testPublicIPID): + writeJSON(t, w, map[string]any{ + "id": testPublicIPID, + "ip": testPublicIPAddress, + }) + case r.Method == http.MethodPut && strings.HasSuffix(path, "/servers/"+testServerID+"/public-ips/"+testPublicIPID): + w.WriteHeader(http.StatusConflict) + writeJSON(t, w, map[string]any{"message": "conflict"}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(contextWithLogCapture(&logs)); err != nil { + t.Fatalf("Reconcile() error = %v, want nil on conflict", err) + } + if recordedID != testPublicIPID { + t.Fatalf("recordedID = %q, want %q", recordedID, testPublicIPID) + } + joined := strings.Join(logs, "\n") + if !strings.Contains(joined, "Public IP already attached to server") || !strings.Contains(joined, `"err"=`) { + t.Fatalf("logs = %v, want no-op attach log with error", logs) + } + if strings.Contains(joined, "Attached public IP to server") { + t.Fatalf("logs = %v, did not expect Attached public IP to server on conflict", logs) + } + }) + + t.Run("returns ErrConflict when multiple public IPs match tags", func(t *testing.T) { + spec := publicip.PublicIPSpec{ + Tags: map[string]string{"cluster": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testPublicIPID, "ip": testPublicIPAddress, "labels": map[string]any{"cluster": "test"}}, + map[string]any{"id": testOtherPublicIPID, "ip": "203.0.113.23", "labels": map[string]any{"cluster": "test"}}, + }}) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrConflict) { + t.Fatalf("Reconcile() error = %v, want ErrConflict", err) + } + }) + + t.Run("returns ErrInvalidInput when tags are empty", func(t *testing.T) { + svc := newTestService(t, publicip.PublicIPSpec{}, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Reconcile(context.Background()); !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Reconcile() error = %v, want ErrInvalidInput", err) + } + }) +} + +func TestServiceDelete(t *testing.T) { + t.Run("detaches and deletes public IP using recorded ID and clears state", func(t *testing.T) { + var ( + detachedPair string + deletedID string + cleared = &publicip.PublicIP{ID: "not-cleared", IP: "not-cleared"} + ) + spec := publicip.PublicIPSpec{ + ID: testPublicIPID, + ServerID: testServerID, + SetPublicIP: func(pip *publicip.PublicIP) { + cleared = pip + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/servers/"+testServerID+"/public-ips/"+testPublicIPID): + detachedPair = testServerID + ":" + testPublicIPID + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/public-ips/"+testPublicIPID): + deletedID = testPublicIPID + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if detachedPair != testServerID+":"+testPublicIPID { + t.Fatalf("detachedPair = %q, want %s:%s", detachedPair, testServerID, testPublicIPID) + } + if deletedID != testPublicIPID { + t.Fatalf("deletedID = %q, want %q", deletedID, testPublicIPID) + } + if cleared != nil { + t.Fatalf("cleared = %#v, want nil", cleared) + } + }) + + t.Run("succeeds when no public IP exists", func(t *testing.T) { + spec := publicip.PublicIPSpec{ + Tags: map[string]string{"cluster": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + writeJSON(t, w, map[string]any{"items": []any{}}) + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v, want nil", err) + } + }) + + t.Run("logs no-op when detaching public IP returns conflict or not found", func(t *testing.T) { + for _, status := range []int{http.StatusNotFound, http.StatusConflict} { + var logs []string + spec := publicip.PublicIPSpec{ + ID: testPublicIPID, + ServerID: testServerID, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/servers/"+testServerID+"/public-ips/"+testPublicIPID): + w.WriteHeader(status) + writeJSON(t, w, map[string]any{"message": "no-op"}) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/public-ips/"+testPublicIPID): + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(contextWithLogCapture(&logs)); err != nil { + t.Fatalf("Delete() error = %v", err) + } + joined := strings.Join(logs, "\n") + if !strings.Contains(joined, "Public IP already detached from server") || !strings.Contains(joined, `"err"=`) { + t.Fatalf("status %d: logs = %v, want no-op detach log with error", status, logs) + } + if strings.Contains(joined, "Detached public IP from server") { + t.Fatalf("status %d: logs = %v, did not expect Detached public IP from server", status, logs) + } + } + }) + + t.Run("returns ErrInvalidInput when both ID and tags are empty", func(t *testing.T) { + svc := newTestService(t, publicip.PublicIPSpec{}, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Delete(context.Background()); !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Delete() error = %v, want ErrInvalidInput", err) + } + }) +} + +func TestServiceDeleteTagFallback(t *testing.T) { + var ( + detachedPairs []string + deletedIDs []string + ) + spec := publicip.PublicIPSpec{ + ID: testMissingPublicIP, + Tags: map[string]string{"cluster": "test"}, + ServerSelector: map[string]string{"cluster": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/servers/"+testServerID+"/public-ips/"+testMissingPublicIP): + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/public-ips/"+testMissingPublicIP): + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/public-ips"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testPublicIPID, + "ip": testPublicIPAddress, + "networkInterface": testNetworkInterface, + "labels": map[string]any{"cluster": "test"}, + }, + map[string]any{ + "id": testOtherPublicIPID, + "ip": "203.0.113.23", + "networkInterface": testNetworkInterface, + "labels": map[string]any{"cluster": "test"}, + }, + map[string]any{ + "id": "ignored-pip", + "ip": "203.0.113.24", + "labels": map[string]any{"cluster": "other"}, + }, + }}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/servers"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testServerID, + "name": "bastion", + "machineType": "c2i.1", + "labels": map[string]any{"cluster": "test"}, + }, + }}) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/servers/"+testServerID+"/public-ips/"+testPublicIPID): + detachedPairs = append(detachedPairs, testServerID+":"+testPublicIPID) + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/servers/"+testServerID+"/public-ips/"+testOtherPublicIPID): + detachedPairs = append(detachedPairs, testServerID+":"+testOtherPublicIPID) + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/public-ips/"+testPublicIPID): + deletedIDs = append(deletedIDs, testPublicIPID) + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/public-ips/"+testOtherPublicIPID): + deletedIDs = append(deletedIDs, testOtherPublicIPID) + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if len(detachedPairs) != 2 || detachedPairs[0] != testServerID+":"+testPublicIPID || detachedPairs[1] != testServerID+":"+testOtherPublicIPID { + t.Fatalf("detachedPairs = %v, want [%s:%s %s:%s]", detachedPairs, testServerID, testPublicIPID, testServerID, testOtherPublicIPID) + } + if len(deletedIDs) != 2 || deletedIDs[0] != testPublicIPID || deletedIDs[1] != testOtherPublicIPID { + t.Fatalf("deletedIDs = %v, want [%s %s]", deletedIDs, testPublicIPID, testOtherPublicIPID) + } +} diff --git a/cloud/services/publicip/service.go b/cloud/services/publicip/service.go new file mode 100644 index 0000000..e1181b3 --- /dev/null +++ b/cloud/services/publicip/service.go @@ -0,0 +1,47 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package publicip + +import "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" + +// PublicIP describes a STACKIT public IP resource. +type PublicIP struct { + ID string + IP string + NetworkInterfaceID string +} + +// PublicIPSpec describes the desired state of a STACKIT public IP. +type PublicIPSpec struct { + ID string + Tags map[string]string + ServerID string + ServerSelector map[string]string + SetPublicIP func(publicIP *PublicIP) +} + +// Scope is an interface that provides scope data needed for public IP reconciliation. +type Scope interface { + shared.IaaSClientScope + PublicIPSpec() PublicIPSpec +} + +// Service implements public IPs reconciler. +type Service struct { + scope Scope +} + +// New returns Service from given scope. +func New(scope Scope) *Service { + return &Service{ + scope: scope, + } +} diff --git a/cloud/services/securitygroup/reconcile.go b/cloud/services/securitygroup/reconcile.go new file mode 100644 index 0000000..325cec8 --- /dev/null +++ b/cloud/services/securitygroup/reconcile.go @@ -0,0 +1,308 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package securitygroup + +import ( + "context" + "errors" + "fmt" + "slices" + + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + logf "sigs.k8s.io/controller-runtime/pkg/log" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +func (s *Service) Reconcile(ctx context.Context) error { + log := logf.FromContext(ctx) + for _, spec := range s.scope.SecurityGroupSpecs() { + if err := s.reconcileSecurityGroup(ctx, spec); err != nil { + return err + } + } + log.V(1).Info("Reconciled security group resources") + return nil +} + +func (s *Service) Delete(ctx context.Context) error { + log := logf.FromContext(ctx) + var errs []error + for _, spec := range slices.Backward(s.scope.SecurityGroupSpecs()) { + if err := s.deleteSecurityGroup(ctx, spec); err != nil { + errs = append(errs, err) + } + } + if len(errs) > 0 { + return errors.Join(errs...) + } + log.V(1).Info("Deleted security group resources") + return nil +} + +// get retrieves a STACKIT security group by ID. +func (s *Service) get(ctx context.Context, id string) (*SecurityGroup, error) { + if id == "" { + return nil, fmt.Errorf("%w: security group ID is empty", shared.ErrInvalidInput) + } + securityGroup, err := s.scope.IaaSClient().DefaultAPI.GetSecurityGroup(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute() + if err != nil { + return nil, shared.ClassifySDKError("get security group", err) + } + return securityGroupFromSDK(securityGroup), nil +} + +// findByTags finds a single STACKIT security group matching the given tag selector. +func (s *Service) findByTags(ctx context.Context, tags map[string]string) (*SecurityGroup, error) { + return shared.FindByTags(ctx, tags, s.listByTags, "security group", "security groups") +} + +// listByTags lists STACKIT security groups matching the given tag selector. +func (s *Service) listByTags(ctx context.Context, tags map[string]string) ([]*SecurityGroup, error) { + return shared.ListByTags(tags, func(selector string) ([]iaas.SecurityGroup, error) { + resp, err := s.scope.IaaSClient().DefaultAPI.ListSecurityGroups(ctx, s.scope.ProjectID(), s.scope.Region()). + LabelSelector(selector). + Execute() + if err != nil { + return nil, shared.ClassifySDKError("list security groups", err) + } + return resp.GetItems(), nil + }, securityGroupFromSDK) +} + +// attachToServer attaches a security group to a server idempotently. +// Three error responses are tolerated: +// - conflict: already attached +// - invalid input: duplicate item in security_groups list +// - not found: server has no network port yet +func (s *Service) attachToServer(ctx context.Context, serverID, securityGroupID string) error { + if err := s.scope.IaaSClient().DefaultAPI. + AddSecurityGroupToServer(ctx, s.scope.ProjectID(), s.scope.Region(), serverID, securityGroupID). + Execute(); err != nil { + err := shared.ClassifySDKError("add security group to server", err) + if !shared.IsConflict(err) && !shared.IsInvalidInput(err) && !shared.IsNotFound(err) { + return err + } + logf.FromContext(ctx).V(1).Info("Security group already attached to server", "securityGroupID", securityGroupID, "serverID", serverID, "err", err) + return nil + } + logf.FromContext(ctx).V(1).Info("Attached security group to server", "securityGroupID", securityGroupID, "serverID", serverID) + return nil +} + +// detachFromServer detaches a security group from a server, ignoring NotFound and Conflict errors. +func (s *Service) detachFromServer(ctx context.Context, serverID, securityGroupID string) error { + if err := s.scope.IaaSClient().DefaultAPI. + RemoveSecurityGroupFromServer(ctx, s.scope.ProjectID(), s.scope.Region(), serverID, securityGroupID). + Execute(); err != nil { + err := shared.ClassifySDKError("remove security group from server", err) + if !shared.IsNotFound(err) && !shared.IsConflict(err) { + return err + } + logf.FromContext(ctx).V(1).Info("Security group already detached from server", "securityGroupID", securityGroupID, "serverID", serverID, "err", err) + return nil + } + logf.FromContext(ctx).V(1).Info("Detached security group from server", "securityGroupID", securityGroupID, "serverID", serverID) + return nil +} + +// deleteByID deletes a security group by ID, returning true if the security group existed and was deleted, +// or false if it was already absent. +func (s *Service) deleteByID(ctx context.Context, id string) (bool, error) { + if id == "" { + return false, fmt.Errorf("%w: security group ID is empty", shared.ErrInvalidInput) + } + if err := s.scope.IaaSClient().DefaultAPI. + DeleteSecurityGroup(ctx, s.scope.ProjectID(), s.scope.Region(), id). + Execute(); err != nil { + err := shared.ClassifySDKError("delete security group", err) + if shared.IsNotFound(err) { + return false, nil + } + return false, err + } + return true, nil +} + +func (s *Service) reconcileSecurityGroup(ctx context.Context, spec SecurityGroupSpec) error { + if err := spec.validate(); err != nil { + return err + } + securityGroup, err := s.ensureSecurityGroup(ctx, spec) + if err != nil { + return err + } + if spec.SetSecurityGroup != nil { + spec.SetSecurityGroup(securityGroup) + } + if err := s.ensureSecurityGroupRules(ctx, securityGroup.ID, spec.Rules); err != nil { + return err + } + for _, serverID := range spec.ServerIDs { + if serverID == "" { + continue + } + if err := s.attachToServer(ctx, serverID, securityGroup.ID); err != nil { + return err + } + } + return nil +} + +func (s *Service) deleteSecurityGroup(ctx context.Context, spec SecurityGroupSpec) error { + if spec.ID == "" && len(spec.Tags) == 0 { + return fmt.Errorf("%w: security group ID or tags are required", shared.ErrInvalidInput) + } + + deletedIDs, err := shared.DeleteByIDOrTags(ctx, spec.ID, spec.Tags, func(ctx context.Context, id string) (bool, error) { + return s.cleanupAndDeleteByID(ctx, id, spec) + }, s.listIDsByTags) + for _, deletedID := range deletedIDs { + logf.FromContext(ctx).V(1).Info("Deleted security group", "securityGroupID", deletedID) + } + if err != nil { + return err + } + if spec.SetSecurityGroup != nil { + spec.SetSecurityGroup(nil) + } + return nil +} + +func (s *Service) cleanupAndDeleteByID(ctx context.Context, id string, spec SecurityGroupSpec) (bool, error) { + rules, ok, err := s.listRulesIfGroupExists(ctx, id) + if err != nil || !ok { + return false, err + } + if err := errors.Join( + s.detachSecurityGroupFromServers(ctx, id, spec), + s.deleteSecurityGroupRules(ctx, id, rules), + ); err != nil { + return false, err + } + return s.deleteByID(ctx, id) +} + +func (s *Service) listIDsByTags(ctx context.Context, tags map[string]string) ([]string, error) { + return shared.ListIDsByTags(ctx, tags, s.listByTags, func(securityGroup *SecurityGroup) string { + return securityGroup.ID + }) +} + +func (s *Service) listRulesIfGroupExists(ctx context.Context, id string) ([]iaas.SecurityGroupRule, bool, error) { + rules, err := s.listSecurityGroupRules(ctx, id) + if shared.IsNotFound(err) { + return nil, false, nil + } + if err != nil { + return nil, false, err + } + return rules, true, nil +} + +func (s *Service) ensureSecurityGroup(ctx context.Context, spec SecurityGroupSpec) (*SecurityGroup, error) { + securityGroup, err := shared.ResolveExisting(ctx, spec.ID, spec.Tags, s.get, s.findByTags, shared.IsNotFound) + if err != nil { + return nil, err + } + if securityGroup != nil { + return securityGroup, nil + } + securityGroupResp, err := s.scope.IaaSClient().DefaultAPI.CreateSecurityGroup(ctx, s.scope.ProjectID(), s.scope.Region()). + CreateSecurityGroupPayload(spec.toCreatePayload()). + Execute() + if err != nil { + return nil, shared.ClassifySDKError("create security group", err) + } + out := securityGroupFromSDK(securityGroupResp) + log := logf.FromContext(ctx) + log.V(1).Info("Created security group", "name", spec.Name, "securityGroupID", out.ID) + return out, nil +} + +func (s *Service) deleteSecurityGroupRules( + ctx context.Context, + id string, + rules []iaas.SecurityGroupRule, +) error { + var errs []error + for _, rule := range rules { + if err := s.deleteSecurityGroupRule(ctx, id, rule.GetId()); err != nil { + errs = append(errs, err) + } + } + return errors.Join(errs...) +} + +func (s *Service) detachSecurityGroupFromServers(ctx context.Context, securityGroupID string, spec SecurityGroupSpec) error { + var errs []error + if err := s.detachServers(ctx, securityGroupID, spec.ServerIDs); err != nil { + errs = append(errs, err) + } + if len(spec.ServerSelector) == 0 { + return errors.Join(errs...) + } + serverIDs, err := shared.ListServerIDsByTags(ctx, s.scope, spec.ServerSelector) + if err != nil { + return errors.Join(append(errs, err)...) + } + if err := s.detachServers(ctx, securityGroupID, serverIDs); err != nil { + errs = append(errs, err) + } + return errors.Join(errs...) +} + +func (s *Service) detachServers(ctx context.Context, securityGroupID string, serverIDs []string) error { + var errs []error + for _, serverID := range serverIDs { + if serverID == "" { + continue + } + if err := s.detachFromServer(ctx, serverID, securityGroupID); err != nil { + errs = append(errs, err) + } + } + return errors.Join(errs...) +} + +func (s SecurityGroupSpec) validate() error { + if s.Name == "" { + return fmt.Errorf("%w: security group name is required", shared.ErrInvalidInput) + } + if len(s.Tags) == 0 { + return fmt.Errorf("%w: security group tags are required", shared.ErrInvalidInput) + } + for _, rule := range s.Rules { + if err := rule.validate(); err != nil { + return err + } + } + return nil +} + +func (s SecurityGroupSpec) toCreatePayload() iaas.CreateSecurityGroupPayload { + payload := iaas.NewCreateSecurityGroupPayload(s.Name) + if s.Description != "" { + payload.SetDescription(s.Description) + } + payload.SetLabels(shared.TagsToSDKLabels(s.Tags)) + return *payload +} + +func securityGroupFromSDK(in *iaas.SecurityGroup) *SecurityGroup { + if in == nil { + return nil + } + return &SecurityGroup{ + ID: in.GetId(), + Name: in.GetName(), + } +} diff --git a/cloud/services/securitygroup/reconcile_test.go b/cloud/services/securitygroup/reconcile_test.go new file mode 100644 index 0000000..3a01ee7 --- /dev/null +++ b/cloud/services/securitygroup/reconcile_test.go @@ -0,0 +1,922 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package securitygroup_test + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "net/http/httptest" + "slices" + "strings" + "testing" + + "github.com/go-logr/logr" + "github.com/go-logr/logr/funcr" + "github.com/stackitcloud/stackit-sdk-go/core/config" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + logf "sigs.k8s.io/controller-runtime/pkg/log" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +const ( + testProjectID = "00000000-0000-0000-0000-000000000000" + testRegion = "eu01" + testSecurityGroupID = "11111111-1111-4111-8111-111111111111" + testRemoteSGID = "22222222-2222-4222-8222-222222222222" + testServerID = "33333333-3333-4333-8333-333333333333" + testRuleID1 = "66666666-6666-4666-8666-666666666666" + testRuleID2 = "77777777-7777-4777-8777-777777777777" +) + +type testScope struct { + projectID string + region string + iaasClient *iaas.APIClient + specs []securitygroup.SecurityGroupSpec +} + +func (s *testScope) ProjectID() string { + return s.projectID +} + +func (s *testScope) Region() string { + return s.region +} + +func (s *testScope) IaaSClient() *iaas.APIClient { + return s.iaasClient +} + +func (s *testScope) SecurityGroupSpecs() []securitygroup.SecurityGroupSpec { + return s.specs +} + +func newTestIaaSClient(t *testing.T, handler http.Handler) *iaas.APIClient { + t.Helper() + + server := httptest.NewServer(handler) + t.Cleanup(server.Close) + + iaasClient, err := iaas.NewAPIClient( + config.WithoutAuthentication(), + config.WithEndpoint(server.URL), + ) + if err != nil { + t.Fatalf("iaas.NewAPIClient() error = %v", err) + } + return iaasClient +} + +func newTestService(t *testing.T, specs []securitygroup.SecurityGroupSpec, handler http.Handler) *securitygroup.Service { + t.Helper() + + return securitygroup.New(&testScope{ + projectID: testProjectID, + region: testRegion, + iaasClient: newTestIaaSClient(t, handler), + specs: specs, + }) +} + +func writeJSON(t *testing.T, w http.ResponseWriter, value any) { + t.Helper() + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(value); err != nil { + t.Fatalf("encode response body: %v", err) + } +} + +func readJSON(t *testing.T, r *http.Request) map[string]any { + t.Helper() + var out map[string]any + if err := json.NewDecoder(r.Body).Decode(&out); err != nil { + t.Fatalf("decode request body: %v", err) + } + return out +} + +func contextWithLogCapture(logs *[]string) context.Context { + logger := funcr.New(func(_, args string) { + *logs = append(*logs, args) + }, funcr.Options{Verbosity: 1}) + return logf.IntoContext(context.Background(), logr.New(logger.GetSink())) +} + +func TestServiceReconcile(t *testing.T) { + t.Run("creates security group and generic rules when not found", func(t *testing.T) { + var ( + createdSGPayload map[string]any + createdRulePayloads []map[string]any + ) + specs := []securitygroup.SecurityGroupSpec{{ + Name: "cluster-sg", + Description: "Generic security group", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{ + { + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 6443, + PortMax: 6443, + IPRange: "203.0.113.0/24", + }, + { + Direction: securitygroup.DirectionEgress, + Protocol: securitygroup.ProtocolUDP, + PortMin: 8472, + PortMax: 8472, + RemoteSecurityGroupID: testRemoteSGID, + }, + }, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/security-groups"): + createdSGPayload = readJSON(t, r) + writeJSON(t, w, map[string]any{ + "id": testSecurityGroupID, + "name": "cluster-sg", + }) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + createdRulePayloads = append(createdRulePayloads, readJSON(t, r)) + writeJSON(t, w, map[string]any{"id": testRuleID1, "direction": "ingress"}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + + if createdSGPayload["name"] != "cluster-sg" { + t.Fatalf("created SG name = %v, want cluster-sg", createdSGPayload["name"]) + } + if createdSGPayload["description"] != "Generic security group" { + t.Fatalf("created SG description = %v, want Generic security group", createdSGPayload["description"]) + } + labels, _ := createdSGPayload["labels"].(map[string]any) + if labels["cluster"] != "test" { + t.Fatalf("created SG labels = %v, want cluster=test", labels) + } + if len(createdRulePayloads) != 2 { + t.Fatalf("created %d rules, want 2", len(createdRulePayloads)) + } + if createdRulePayloads[0]["direction"] != "ingress" || createdRulePayloads[0]["ipRange"] != "203.0.113.0/24" { + t.Fatalf("first rule payload = %#v", createdRulePayloads[0]) + } + if createdRulePayloads[1]["direction"] != "egress" || createdRulePayloads[1]["remoteSecurityGroupId"] != testRemoteSGID { + t.Fatalf("second rule payload = %#v", createdRulePayloads[1]) + } + }) +} + +func TestServiceReconcileReuseAndErrors(t *testing.T) { + t.Run("reuses existing security group found by ID without listing by tags", func(t *testing.T) { + var recordedID string + specs := []securitygroup.SecurityGroupSpec{{ + ID: testSecurityGroupID, + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + SetSecurityGroup: func(sg *securitygroup.SecurityGroup) { + recordedID = sg.ID + }, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID): + writeJSON(t, w, map[string]any{ + "id": testSecurityGroupID, + "name": "cluster-sg", + }) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if recordedID != testSecurityGroupID { + t.Fatalf("recordedID = %q, want %q", recordedID, testSecurityGroupID) + } + }) + + t.Run("falls back to tag lookup when recorded ID is not found during reconcile", func(t *testing.T) { + var ( + getByIDCalled bool + recordedID string + ) + staleID := "99999999-9999-4999-8999-999999999999" + specs := []securitygroup.SecurityGroupSpec{{ + ID: staleID, + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + SetSecurityGroup: func(sg *securitygroup.SecurityGroup) { + recordedID = sg.ID + }, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+staleID): + getByIDCalled = true + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testSecurityGroupID, + "name": "cluster-sg", + "labels": map[string]any{"cluster": "test"}, + }, + }}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if !getByIDCalled { + t.Fatal("expected GET by spec.ID before falling back to tag lookup") + } + if recordedID != testSecurityGroupID { + t.Fatalf("recordedID = %q, want %q", recordedID, testSecurityGroupID) + } + }) + + t.Run("reuses existing security group found by tags without creating duplicate", func(t *testing.T) { + specs := []securitygroup.SecurityGroupSpec{{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testSecurityGroupID, + "name": "cluster-sg", + "labels": map[string]any{"cluster": "test"}, + }, + }}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + }) + + t.Run("returns ErrConflict when multiple security groups match tags", func(t *testing.T) { + specs := []securitygroup.SecurityGroupSpec{{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testSecurityGroupID, "name": "sg-1", "labels": map[string]any{"cluster": "test"}}, + map[string]any{"id": testRemoteSGID, "name": "sg-2", "labels": map[string]any{"cluster": "test"}}, + }}) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrConflict) { + t.Fatalf("Reconcile() error = %v, want ErrConflict", err) + } + }) + + t.Run("returns retryable ErrTransient when remote security group referenced by tags does not exist yet", func(t *testing.T) { + specs := []securitygroup.SecurityGroupSpec{{ + ID: testSecurityGroupID, + Name: "node-ssh", + Tags: map[string]string{"role": "node-ssh"}, + Rules: []securitygroup.Rule{{ + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 22, + PortMax: 22, + RemoteSecurityGroupTags: map[string]string{"role": "bastion"}, + }}, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID): + writeJSON(t, w, map[string]any{"id": testSecurityGroupID, "name": "node-ssh"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + writeJSON(t, w, map[string]any{"items": []any{}}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrTransient) { + t.Fatalf("Reconcile() error = %v, want ErrTransient", err) + } + }) +} + +func TestServiceReconcileAttachNoOpLogging(t *testing.T) { + for _, status := range []int{http.StatusConflict, http.StatusBadRequest, http.StatusNotFound} { + var logs []string + specs := []securitygroup.SecurityGroupSpec{{ + ID: testSecurityGroupID, + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + ServerIDs: []string{testServerID}, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID): + writeJSON(t, w, map[string]any{"id": testSecurityGroupID, "name": "cluster-sg"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodPut && strings.HasSuffix(path, "/servers/"+testServerID+"/security-groups/"+testSecurityGroupID): + w.WriteHeader(status) + writeJSON(t, w, map[string]any{"message": "no-op"}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(contextWithLogCapture(&logs)); err != nil { + t.Fatalf("status %d: Reconcile() error = %v", status, err) + } + joined := strings.Join(logs, "\n") + if !strings.Contains(joined, "Security group already attached to server") || !strings.Contains(joined, `"err"=`) { + t.Fatalf("status %d: logs = %v, want no-op attach log with error", status, logs) + } + if strings.Contains(joined, "Attached security group to server") { + t.Fatalf("status %d: logs = %v, did not expect Attached security group to server", status, logs) + } + } +} + +func TestServiceReconcileBastionAndNodeSSH(t *testing.T) { + var ( + bastionSGID string + bastionCreated bool + nodeRulesCreated []map[string]any + attachedServerIDs []string + ) + specs := []securitygroup.SecurityGroupSpec{ + { + Name: "cluster-bastion-ssh", + Tags: map[string]string{"role": "bastion"}, + SetSecurityGroup: func(sg *securitygroup.SecurityGroup) { + bastionSGID = sg.ID + }, + Rules: []securitygroup.Rule{ + { + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 22, + PortMax: 22, + IPRange: "203.0.113.0/24", + }, + { + Direction: securitygroup.DirectionEgress, + }, + }, + }, + { + Name: "cluster-node-ssh", + Tags: map[string]string{"role": "node-ssh"}, + ServerIDs: []string{testServerID}, + Rules: []securitygroup.Rule{ + { + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 22, + PortMax: 22, + RemoteSecurityGroupTags: map[string]string{"role": "bastion"}, + }, + { + Direction: securitygroup.DirectionEgress, + }, + }, + }, + } + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + selector := r.URL.Query().Get("label_selector") + if bastionCreated && strings.Contains(selector, "role=bastion") { + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testRemoteSGID, + "name": "cluster-bastion-ssh", + "labels": map[string]any{"role": "bastion"}, + }, + }}) + return + } + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/security-groups"): + payload := readJSON(t, r) + if payload["name"] == "cluster-bastion-ssh" { + bastionCreated = true + writeJSON(t, w, map[string]any{"id": testRemoteSGID, "name": "cluster-bastion-ssh"}) + return + } + writeJSON(t, w, map[string]any{"id": testSecurityGroupID, "name": "cluster-node-ssh"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testRemoteSGID+"/rules"): + // Simulate STACKIT default egress rule already present. + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testRuleID1, "direction": "egress", "ethertype": "IPv4"}, + }}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/security-groups/"+testRemoteSGID+"/rules"): + writeJSON(t, w, map[string]any{"id": testRuleID2, "direction": "ingress"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + nodeRulesCreated = append(nodeRulesCreated, readJSON(t, r)) + writeJSON(t, w, map[string]any{"id": testRuleID1, "direction": "ingress"}) + case r.Method == http.MethodPut && strings.HasSuffix(path, "/servers/"+testServerID+"/security-groups/"+testSecurityGroupID): + attachedServerIDs = append(attachedServerIDs, testServerID) + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if bastionSGID != testRemoteSGID { + t.Fatalf("bastionSGID = %q, want %q", bastionSGID, testRemoteSGID) + } + if len(nodeRulesCreated) != 2 { + t.Fatalf("nodeRulesCreated = %#v, want 2 rules (ingress from bastion + egress)", nodeRulesCreated) + } + if nodeRulesCreated[0]["remoteSecurityGroupId"] != testRemoteSGID { + t.Fatalf("node ingress rule remoteSecurityGroupId = %v, want %q", nodeRulesCreated[0]["remoteSecurityGroupId"], testRemoteSGID) + } + if nodeRulesCreated[1]["direction"] != "egress" { + t.Fatalf("node egress rule direction = %v, want egress", nodeRulesCreated[1]["direction"]) + } + if !slices.Equal(attachedServerIDs, []string{testServerID}) { + t.Fatalf("attachedServerIDs = %v, want [%s]", attachedServerIDs, testServerID) + } +} + +func TestServiceReconcileRules(t *testing.T) { + var ( + createdRules []map[string]any + deletedRuleIDs []string + ) + specs := []securitygroup.SecurityGroupSpec{{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{ + { + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 443, + PortMax: 443, + IPRange: "203.0.113.0/24", + }, + { + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 443, + PortMax: 443, + IPRange: "203.0.113.0/24", + }, + { + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 10250, + PortMax: 10250, + RemoteSecurityGroupID: testRemoteSGID, + }, + }, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testSecurityGroupID, + "name": "cluster-sg", + "labels": map[string]any{"cluster": "test"}, + }, + }}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testRuleID1, + "direction": "ingress", + "remoteSecurityGroupId": testRemoteSGID, + "portRange": map[string]any{"min": 10250, "max": 10250}, + "protocol": map[string]any{"name": "tcp"}, + }, + map[string]any{ + "id": testRuleID2, + "direction": "ingress", + "ipRange": "198.51.100.0/24", + "portRange": map[string]any{"min": 22, "max": 22}, + "protocol": map[string]any{"name": "tcp"}, + }, + }}) + case r.Method == http.MethodPost && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + createdRules = append(createdRules, readJSON(t, r)) + writeJSON(t, w, map[string]any{"id": "88888888-8888-4888-8888-888888888888", "direction": "ingress"}) + case r.Method == http.MethodDelete && strings.Contains(path, "/rules/"): + parts := strings.Split(strings.TrimSuffix(path, "/"), "/") + deletedRuleIDs = append(deletedRuleIDs, parts[len(parts)-1]) + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + + if len(createdRules) != 1 || createdRules[0]["ipRange"] != "203.0.113.0/24" { + t.Fatalf("createdRules = %#v, want single rule for 203.0.113.0/24", createdRules) + } + if !slices.Equal(deletedRuleIDs, []string{testRuleID2}) { + t.Fatalf("deletedRuleIDs = %v, want [%s]", deletedRuleIDs, testRuleID2) + } +} + +func TestServiceReconcileValidation(t *testing.T) { + tests := []struct { + name string + spec securitygroup.SecurityGroupSpec + }{ + { + name: "missing name", + spec: securitygroup.SecurityGroupSpec{ + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "missing tags", + spec: securitygroup.SecurityGroupSpec{ + Name: "cluster-sg", + }, + }, + { + name: "invalid rule direction", + spec: securitygroup.SecurityGroupSpec{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{{Direction: "invalid", Protocol: securitygroup.ProtocolTCP, PortMin: 80, PortMax: 80, IPRange: "0.0.0.0/0"}}, + }, + }, + { + name: "both ipRange and remoteSecurityGroupID set", + spec: securitygroup.SecurityGroupSpec{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{{ + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 80, + PortMax: 80, + IPRange: "0.0.0.0/0", + RemoteSecurityGroupID: testRemoteSGID, + }}, + }, + }, + { + name: "both ipRange and remoteSecurityGroupTags set", + spec: securitygroup.SecurityGroupSpec{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{{ + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 80, + PortMax: 80, + IPRange: "0.0.0.0/0", + RemoteSecurityGroupTags: map[string]string{"role": "bastion"}, + }}, + }, + }, + { + name: "invalid port range", + spec: securitygroup.SecurityGroupSpec{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{{Direction: securitygroup.DirectionIngress, Protocol: securitygroup.ProtocolTCP, PortMin: 8080, PortMax: 80, IPRange: "0.0.0.0/0"}}, + }, + }, + { + name: "port range without protocol", + spec: securitygroup.SecurityGroupSpec{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{{Direction: securitygroup.DirectionIngress, PortMin: 80, PortMax: 80, IPRange: "0.0.0.0/0"}}, + }, + }, + { + name: "invalid ipRange CIDR", + spec: securitygroup.SecurityGroupSpec{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{{Direction: securitygroup.DirectionIngress, Protocol: securitygroup.ProtocolTCP, PortMin: 22, PortMax: 22, IPRange: "not-a-cidr"}}, + }, + }, + { + name: "ingress rule without ipRange or remoteSecurityGroup", + spec: securitygroup.SecurityGroupSpec{ + Name: "cluster-sg", + Tags: map[string]string{"cluster": "test"}, + Rules: []securitygroup.Rule{{Direction: securitygroup.DirectionIngress, Protocol: securitygroup.ProtocolTCP, PortMin: 22, PortMax: 22}}, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + svc := newTestService(t, []securitygroup.SecurityGroupSpec{tt.spec}, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request before validation failure: %s %s", r.Method, r.URL.String()) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Reconcile() error = %v, want ErrInvalidInput", err) + } + }) + } +} + +func TestServiceDelete(t *testing.T) { + t.Run("deletes rules and security group using ID when provided", func(t *testing.T) { + var ( + deletedRules []string + deletedSGID string + cleared = &securitygroup.SecurityGroup{ID: "not-cleared", Name: "not-cleared"} + ) + specs := []securitygroup.SecurityGroupSpec{{ + ID: testSecurityGroupID, + SetSecurityGroup: func(sg *securitygroup.SecurityGroup) { + cleared = sg + }, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testRuleID1, "direction": "ingress"}, + map[string]any{"id": testRuleID2, "direction": "egress"}, + }}) + case r.Method == http.MethodDelete && strings.Contains(path, "/rules/"): + parts := strings.Split(strings.TrimSuffix(path, "/"), "/") + deletedRules = append(deletedRules, parts[len(parts)-1]) + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID): + deletedSGID = testSecurityGroupID + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if !slices.Equal(deletedRules, []string{testRuleID1, testRuleID2}) { + t.Fatalf("deletedRules = %v, want [%s %s]", deletedRules, testRuleID1, testRuleID2) + } + if deletedSGID != testSecurityGroupID { + t.Fatalf("deletedSGID = %q, want %q", deletedSGID, testSecurityGroupID) + } + if cleared != nil { + t.Fatalf("cleared = %#v, want nil", cleared) + } + }) + + t.Run("deletes rules and all security groups found by tags", func(t *testing.T) { + var ( + deletedRules []string + deletedSGIDs []string + ) + specs := []securitygroup.SecurityGroupSpec{{ + Tags: map[string]string{"cluster": "test"}, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testSecurityGroupID, "name": "cluster-sg", "labels": map[string]any{"cluster": "test"}}, + map[string]any{"id": testRemoteSGID, "name": "bastion-sg", "labels": map[string]any{"cluster": "test"}}, + map[string]any{"id": "ignored-sg", "name": "other-sg", "labels": map[string]any{"cluster": "other"}}, + }}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testRuleID1, "direction": "ingress"}, + map[string]any{"id": testRuleID2, "direction": "egress"}, + }}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testRemoteSGID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodDelete && strings.Contains(path, "/rules/"): + parts := strings.Split(strings.TrimSuffix(path, "/"), "/") + deletedRules = append(deletedRules, parts[len(parts)-1]) + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID): + deletedSGIDs = append(deletedSGIDs, testSecurityGroupID) + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/security-groups/"+testRemoteSGID): + deletedSGIDs = append(deletedSGIDs, testRemoteSGID) + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if !slices.Equal(deletedRules, []string{testRuleID1, testRuleID2}) { + t.Fatalf("deletedRules = %v, want [%s %s]", deletedRules, testRuleID1, testRuleID2) + } + if !slices.Equal(deletedSGIDs, []string{testSecurityGroupID, testRemoteSGID}) { + t.Fatalf("deletedSGIDs = %v, want [%s %s]", deletedSGIDs, testSecurityGroupID, testRemoteSGID) + } + }) + + t.Run("succeeds when security group does not exist", func(t *testing.T) { + specs := []securitygroup.SecurityGroupSpec{{ + Tags: map[string]string{"cluster": "test"}, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + writeJSON(t, w, map[string]any{"items": []any{}}) + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v, want nil", err) + } + }) + + t.Run("returns ErrInvalidInput when tags are empty", func(t *testing.T) { + svc := newTestService(t, []securitygroup.SecurityGroupSpec{{}}, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + err := svc.Delete(context.Background()) + if !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Delete() error = %v, want ErrInvalidInput", err) + } + }) +} + +func TestServiceDeleteDetachNoOpLogging(t *testing.T) { + for _, status := range []int{http.StatusNotFound, http.StatusConflict} { + var logs []string + specs := []securitygroup.SecurityGroupSpec{{ + ID: testSecurityGroupID, + ServerIDs: []string{testServerID}, + }} + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID+"/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/servers/"+testServerID+"/security-groups/"+testSecurityGroupID): + w.WriteHeader(status) + writeJSON(t, w, map[string]any{"message": "no-op"}) + case r.Method == http.MethodDelete && strings.HasSuffix(path, "/security-groups/"+testSecurityGroupID): + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(contextWithLogCapture(&logs)); err != nil { + t.Fatalf("status %d: Delete() error = %v", status, err) + } + joined := strings.Join(logs, "\n") + if !strings.Contains(joined, "Security group already detached from server") || !strings.Contains(joined, `"err"=`) { + t.Fatalf("status %d: logs = %v, want no-op detach log with error", status, logs) + } + if strings.Contains(joined, "Detached security group from server") { + t.Fatalf("status %d: logs = %v, did not expect Detached security group from server", status, logs) + } + } +} + +func TestServiceDeleteStaleIDFallbackAndDetach(t *testing.T) { + var ( + detachedPairs []string + deletedSGIDs []string + ) + specs := []securitygroup.SecurityGroupSpec{ + { + ID: "99999999-9999-4999-8999-999999999999", + Tags: map[string]string{"role": "bastion"}, + }, + { + Tags: map[string]string{"role": "node-ssh"}, + ServerSelector: map[string]string{"cluster": "test"}, + }, + } + + svc := newTestService(t, specs, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups/99999999-9999-4999-8999-999999999999/rules"): + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/security-groups"): + selector := r.URL.Query().Get("label_selector") + if strings.Contains(selector, "role=node-ssh") { + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testSecurityGroupID, "name": "node-ssh", "labels": map[string]any{"role": "node-ssh"}}, + }}) + return + } + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testRemoteSGID, "name": "bastion-ssh", "labels": map[string]any{"role": "bastion"}}, + }}) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/servers"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testServerID, + "name": "worker-1", + "machineType": "c2i.1", + "labels": map[string]any{"cluster": "test"}, + }, + }}) + case r.Method == http.MethodDelete && strings.Contains(path, "/servers/") && strings.Contains(path, "/security-groups/"): + parts := strings.Split(path, "/servers/") + sub := strings.Split(parts[1], "/security-groups/") + detachedPairs = append(detachedPairs, sub[0]+":"+sub[1]) + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodGet && strings.HasSuffix(path, "/rules"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodDelete && strings.Contains(path, "/security-groups/"): + id := path[strings.LastIndex(path, "/security-groups/")+len("/security-groups/"):] + deletedSGIDs = append(deletedSGIDs, id) + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if !slices.Equal(detachedPairs, []string{testServerID + ":" + testSecurityGroupID}) { + t.Fatalf("detachedPairs = %v, want [%s:%s]", detachedPairs, testServerID, testSecurityGroupID) + } + if !slices.Equal(deletedSGIDs, []string{testSecurityGroupID, testRemoteSGID}) { + t.Fatalf("deletedSGIDs = %v, want [%s %s] (reverse order: node-ssh then bastion-ssh)", deletedSGIDs, testSecurityGroupID, testRemoteSGID) + } +} diff --git a/cloud/services/securitygroup/rules.go b/cloud/services/securitygroup/rules.go new file mode 100644 index 0000000..73514f4 --- /dev/null +++ b/cloud/services/securitygroup/rules.go @@ -0,0 +1,214 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package securitygroup + +import ( + "context" + "fmt" + "net/netip" + "slices" + "strings" + + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +func (s *Service) ensureSecurityGroupRules(ctx context.Context, securityGroupID string, rules []Rule) error { + if securityGroupID == "" { + return fmt.Errorf("%w: security group ID is required", shared.ErrInvalidInput) + } + existingRules, err := s.listSecurityGroupRules(ctx, securityGroupID) + if err != nil { + return err + } + desired := make([]Rule, 0, len(rules)) + for _, rule := range rules { + rule, err := s.resolveRule(ctx, rule) + if err != nil { + return err + } + if slices.ContainsFunc(desired, rule.equal) { + continue + } + desired = append(desired, rule) + if hasRule(existingRules, rule) { + continue + } + if err := s.createSecurityGroupRule(ctx, securityGroupID, rule); err != nil { + return err + } + } + + for _, existing := range existingRules { + if slices.ContainsFunc(desired, ruleFromSDK(existing).equal) { + continue + } + if err := s.deleteSecurityGroupRule(ctx, securityGroupID, existing.GetId()); err != nil { + return err + } + } + return nil +} + +func (s *Service) resolveRule(ctx context.Context, rule Rule) (Rule, error) { + rule = rule.normalize() + if rule.RemoteSecurityGroupID == "" && len(rule.RemoteSecurityGroupTags) > 0 { + remoteSG, err := s.findByTags(ctx, rule.RemoteSecurityGroupTags) + if err != nil { + if shared.IsNotFound(err) { + return Rule{}, fmt.Errorf("%w: remote security group not ready: %v", shared.ErrTransient, err) + } + return Rule{}, err + } + rule.RemoteSecurityGroupID = remoteSG.ID + } + rule.RemoteSecurityGroupTags = nil + return rule, nil +} + +func (s *Service) createSecurityGroupRule(ctx context.Context, securityGroupID string, rule Rule) error { + if _, err := s.scope.IaaSClient().DefaultAPI.CreateSecurityGroupRule(ctx, s.scope.ProjectID(), s.scope.Region(), securityGroupID). + CreateSecurityGroupRulePayload(rule.toCreatePayload()). + Execute(); err != nil { + return shared.ClassifySDKError("create security group rule", err) + } + return nil +} + +func (s *Service) listSecurityGroupRules(ctx context.Context, securityGroupID string) ([]iaas.SecurityGroupRule, error) { + resp, err := s.scope.IaaSClient().DefaultAPI.ListSecurityGroupRules(ctx, s.scope.ProjectID(), s.scope.Region(), securityGroupID).Execute() + if err != nil { + return nil, shared.ClassifySDKError("list security group rules", err) + } + return resp.GetItems(), nil +} + +func (s *Service) deleteSecurityGroupRule(ctx context.Context, securityGroupID, ruleID string) error { + if ruleID == "" { + return nil + } + if err := s.scope.IaaSClient().DefaultAPI. + DeleteSecurityGroupRule(ctx, s.scope.ProjectID(), s.scope.Region(), securityGroupID, ruleID). + Execute(); err != nil { + err := shared.ClassifySDKError("delete security group rule", err) + if !shared.IsNotFound(err) { + return err + } + } + return nil +} + +func (r Rule) validate() error { + if r.Direction != DirectionIngress && r.Direction != DirectionEgress { + return fmt.Errorf( + "%w: security group rule direction must be %q or %q", + shared.ErrInvalidInput, + DirectionIngress, + DirectionEgress, + ) + } + hasRemoteSecurityGroup := r.RemoteSecurityGroupID != "" || len(r.RemoteSecurityGroupTags) > 0 + if r.Direction == DirectionIngress && r.IPRange == "" && !hasRemoteSecurityGroup { + return fmt.Errorf( + "%w: ingress security group rule requires ipRange or remoteSecurityGroupID", + shared.ErrInvalidInput, + ) + } + if r.IPRange != "" { + if hasRemoteSecurityGroup { + return fmt.Errorf( + "%w: security group rule cannot specify both ipRange and remoteSecurityGroupID", + shared.ErrInvalidInput, + ) + } + if _, err := netip.ParsePrefix(r.IPRange); err != nil { + return fmt.Errorf("%w: security group rule has invalid ipRange CIDR %q", shared.ErrInvalidInput, r.IPRange) + } + } + if r.hasInvalidPortRange() { + return fmt.Errorf("%w: invalid security group rule port range", shared.ErrInvalidInput) + } + if r.hasPortRange() && r.Protocol == "" { + return fmt.Errorf("%w: security group rule port range requires a protocol", shared.ErrInvalidInput) + } + return nil +} + +func (r Rule) hasPortRange() bool { + return r.PortMin > 0 || r.PortMax > 0 +} + +func (r Rule) hasInvalidPortRange() bool { + return r.PortMin < 0 || r.PortMax < 0 || r.PortMin > r.PortMax +} + +func (p Protocol) normalize() Protocol { + return Protocol(strings.ToLower(string(p))) +} + +func (r Rule) normalize() Rule { + r.Protocol = r.Protocol.normalize() + return r +} + +func (r Rule) equal(other Rule) bool { + return r.Direction == other.Direction && + r.Protocol == other.Protocol && + r.PortMin == other.PortMin && + r.PortMax == other.PortMax && + r.IPRange == other.IPRange && + r.RemoteSecurityGroupID == other.RemoteSecurityGroupID +} + +func (r Rule) toCreatePayload() iaas.CreateSecurityGroupRulePayload { + payload := iaas.NewCreateSecurityGroupRulePayload(string(r.Direction)) + if r.Protocol != "" { + protocol := iaas.StringAsCreateProtocol(new(string(r.Protocol))) + payload.SetProtocol(protocol) + } + if r.hasPortRange() { + payload.SetPortRange(*iaas.NewPortRange(r.PortMin, r.PortMax)) + } + if r.IPRange != "" { + payload.SetIpRange(r.IPRange) + } + if r.RemoteSecurityGroupID != "" { + payload.SetRemoteSecurityGroupId(r.RemoteSecurityGroupID) + } + return *payload +} + +func hasRule(rules []iaas.SecurityGroupRule, desired Rule) bool { + return slices.ContainsFunc(rules, func(rule iaas.SecurityGroupRule) bool { + return ruleFromSDK(rule).equal(desired) + }) +} + +func ruleFromSDK(in iaas.SecurityGroupRule) Rule { + var ruleProtocol Protocol + if protocol, ok := in.GetProtocolOk(); ok { + ruleProtocol = Protocol(protocol.GetName()).normalize() + } + var portMin, portMax int64 + if portRange, ok := in.GetPortRangeOk(); ok { + portMin = portRange.GetMin() + portMax = portRange.GetMax() + } + return Rule{ + Direction: Direction(in.GetDirection()), + Protocol: ruleProtocol, + PortMin: portMin, + PortMax: portMax, + IPRange: in.GetIpRange(), + RemoteSecurityGroupID: in.GetRemoteSecurityGroupId(), + } +} diff --git a/cloud/services/securitygroup/service.go b/cloud/services/securitygroup/service.go new file mode 100644 index 0000000..309098a --- /dev/null +++ b/cloud/services/securitygroup/service.go @@ -0,0 +1,77 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package securitygroup + +import "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" + +// Direction specifies the traffic direction of a security group rule. +type Direction string + +const ( + DirectionIngress Direction = "ingress" + DirectionEgress Direction = "egress" +) + +// Protocol specifies the network protocol of a security group rule. +type Protocol string + +const ( + ProtocolTCP Protocol = "tcp" + ProtocolUDP Protocol = "udp" + ProtocolICMP Protocol = "icmp" +) + +// SecurityGroup describes a STACKIT security group. +type SecurityGroup struct { + ID string + Name string +} + +// Rule describes a desired STACKIT security group rule. +type Rule struct { + Direction Direction + Protocol Protocol + PortMin int64 + PortMax int64 + IPRange string + RemoteSecurityGroupID string + RemoteSecurityGroupTags map[string]string +} + +// SecurityGroupSpec describes the desired state of a STACKIT security group and its rules. +type SecurityGroupSpec struct { + ID string + Name string + Description string + Tags map[string]string + Rules []Rule + ServerIDs []string + ServerSelector map[string]string + SetSecurityGroup func(securityGroup *SecurityGroup) +} + +// Scope is an interface that provides scope data needed for security group reconciliation. +type Scope interface { + shared.IaaSClientScope + SecurityGroupSpecs() []SecurityGroupSpec +} + +// Service implements security groups reconciler. +type Service struct { + scope Scope +} + +// New returns Service from given scope. +func New(scope Scope) *Service { + return &Service{ + scope: scope, + } +} diff --git a/cloud/services/server/reconcile.go b/cloud/services/server/reconcile.go new file mode 100644 index 0000000..5dd1926 --- /dev/null +++ b/cloud/services/server/reconcile.go @@ -0,0 +1,234 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package server + +import ( + "context" + "encoding/base64" + "fmt" + + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + logf "sigs.k8s.io/controller-runtime/pkg/log" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +func (s *Service) Reconcile(ctx context.Context) error { + log := logf.FromContext(ctx) + spec := s.scope.ServerSpec() + if err := spec.validate(); err != nil { + return err + } + + srv, created, err := s.ensureServer(ctx, spec) + if err != nil { + return err + } + if spec.SetServer != nil { + spec.SetServer(srv, created) + } + log.V(1).Info("Reconciled server resources", "serverID", srv.ID, "created", created) + return nil +} + +func (s *Service) Delete(ctx context.Context) error { + log := logf.FromContext(ctx) + spec := s.scope.ServerSpec() + if spec.ID == "" && len(spec.Tags) == 0 { + return fmt.Errorf("%w: server ID or tags are required", shared.ErrInvalidInput) + } + + deletedIDs, err := shared.DeleteByIDOrTags(ctx, spec.ID, spec.Tags, s.deleteByID, func(ctx context.Context, tags map[string]string) ([]string, error) { + return shared.ListServerIDsByTags(ctx, s.scope, tags) + }) + for _, deletedID := range deletedIDs { + log.V(1).Info("Deleted server", "serverID", deletedID) + } + if err != nil { + return err + } + if spec.SetServer != nil { + spec.SetServer(nil, false) + } + return nil +} + +// get retrieves a STACKIT server by ID. +func (s *Service) get(ctx context.Context, id string) (*Server, error) { + if id == "" { + return nil, fmt.Errorf("%w: server ID is empty", shared.ErrInvalidInput) + } + srv, err := s.scope.IaaSClient().DefaultAPI.GetServer(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute() + if err != nil { + return nil, shared.ClassifySDKError("get server", err) + } + return s.serverFromSDK(ctx, srv), nil +} + +// findByTags finds a single STACKIT server matching the given tag selector. +func (s *Service) findByTags(ctx context.Context, tags map[string]string) (*Server, error) { + srv, err := shared.FindByTags(ctx, tags, func(ctx context.Context, tags map[string]string) ([]*iaas.Server, error) { + return shared.ListServersByTags(ctx, s.scope, tags) + }, "server", "servers") + if err != nil { + return nil, err + } + return s.serverFromSDK(ctx, srv), nil +} + +// deleteByID deletes a server by ID, returning true if the server existed and was deleted, +// or false if it was already absent. +func (s *Service) deleteByID(ctx context.Context, id string) (bool, error) { + if id == "" { + return false, fmt.Errorf("%w: server ID is empty", shared.ErrInvalidInput) + } + if err := s.scope.IaaSClient().DefaultAPI.DeleteServer(ctx, s.scope.ProjectID(), s.scope.Region(), id).Execute(); err != nil { + err := shared.ClassifySDKError("delete server", err) + if shared.IsNotFound(err) { + return false, nil + } + return false, err + } + return true, nil +} + +// create creates a new STACKIT server from the given spec. +func (s *Service) create(ctx context.Context, spec ServerSpec) (*Server, error) { + payload := spec.toCreatePayload() + created, err := s.scope.IaaSClient().DefaultAPI.CreateServer(ctx, s.scope.ProjectID(), s.scope.Region()). + CreateServerPayload(payload). + Execute() + if err != nil { + return nil, shared.ClassifySDKError("create server", err) + } + out := s.serverFromSDK(ctx, created) + logf.FromContext(ctx).V(1).Info("Created server", "name", spec.Name, "serverID", out.ID) + return out, nil +} + +func (s *Service) ensureServer(ctx context.Context, spec ServerSpec) (*Server, bool, error) { + srv, err := shared.ResolveExisting(ctx, spec.ID, spec.Tags, s.get, s.findByTags, shared.IsNotFound) + if err != nil { + return nil, false, err + } + if srv != nil { + return srv, false, nil + } + + // Recreating an already-provisioned server would replay bootstrap data + // pinned to the previous identity, so surface the loss and let Cluster API + // replace the Machine. + if spec.DisallowRecreate { + return nil, false, fmt.Errorf( + "%w: server %s; the Machine must be replaced", + errServerGone, spec.ID, + ) + } + + out, err := s.create(ctx, spec) + if err != nil { + return nil, false, err + } + return out, true, nil +} + +func (s ServerSpec) validate() error { + if s.Name == "" { + return fmt.Errorf("%w: server name is required", shared.ErrInvalidInput) + } + if s.ImageID == "" { + return fmt.Errorf("%w: server image ID is required", shared.ErrInvalidInput) + } + if s.MachineType == "" { + return fmt.Errorf("%w: server machine type is required", shared.ErrInvalidInput) + } + if s.RequireSSHKey && s.SSHKeyName == "" { + return fmt.Errorf("%w: server SSH key name is required", shared.ErrInvalidInput) + } + if s.NetworkID == "" { + return fmt.Errorf("%w: server network ID is required", shared.ErrInvalidInput) + } + if len(s.Tags) == 0 { + return fmt.Errorf("%w: server tags are required", shared.ErrInvalidInput) + } + return nil +} + +func (s ServerSpec) toCreatePayload() iaas.CreateServerPayload { + payload := &iaas.CreateServerPayload{} + payload.SetName(s.Name) + payload.SetMachineType(s.MachineType) + useBootVolume := s.RootVolume.SizeGiB > 0 || s.RootVolume.PerformanceClass != "" + if s.ImageID != "" && !useBootVolume { + payload.SetImageId(s.ImageID) + } + if len(s.Tags) > 0 { + payload.SetLabels(shared.TagsToSDKLabels(s.Tags)) + } + networking := iaas.NewCreateServerNetworking() + if s.NetworkID != "" { + networking.SetNetworkId(s.NetworkID) + } + payload.SetNetworking(iaas.CreateServerNetworkingAsCreateServerPayloadAllOfNetworking(networking)) + if len(s.SecurityGroups) > 0 { + payload.SetSecurityGroups(s.SecurityGroups) + } + if len(s.UserData) > 0 { + payload.SetUserData(base64.StdEncoding.EncodeToString(s.UserData)) + payload.SetConfigDrive(true) + } + if useBootVolume { + bootVolume := iaas.NewBootVolume() + if s.ImageID != "" { + bootVolume.SetSource(*iaas.NewBootVolumeSource(s.ImageID, "image")) + } + if s.RootVolume.SizeGiB > 0 { + bootVolume.SetSize(int64(s.RootVolume.SizeGiB)) + } + if s.RootVolume.PerformanceClass != "" { + bootVolume.SetPerformanceClass(s.RootVolume.PerformanceClass) + } + bootVolume.SetDeleteOnTermination(s.RootVolume.DeleteOnTermination) + payload.SetBootVolume(*bootVolume) + } + if s.SSHKeyName != "" { + payload.SetKeypairName(s.SSHKeyName) + } + if s.AvailabilityZone != "" { + payload.SetAvailabilityZone(s.AvailabilityZone) + } + return *payload +} + +func (s *Service) serverFromSDK(ctx context.Context, srv *iaas.Server) *Server { + if srv == nil { + return nil + } + out := &Server{ + ID: srv.GetId(), + Name: srv.GetName(), + State: srv.GetStatus(), + PowerStatus: srv.GetPowerStatus(), + AvailabilityZone: srv.GetAvailabilityZone(), + } + nics, err := s.scope.IaaSClient().DefaultAPI.ListServerNICs(ctx, s.scope.ProjectID(), s.scope.Region(), out.ID).Execute() + if err == nil { + for _, nic := range nics.GetItems() { + if ipv4 := nic.GetIpv4(); ipv4 != "" { + out.Addresses = append(out.Addresses, Address{Type: "InternalIP", Address: ipv4}) + } + if ipv6 := nic.GetIpv6(); ipv6 != "" { + out.Addresses = append(out.Addresses, Address{Type: "InternalIP", Address: ipv6}) + } + } + } + return out +} diff --git a/cloud/services/server/reconcile_test.go b/cloud/services/server/reconcile_test.go new file mode 100644 index 0000000..90a676a --- /dev/null +++ b/cloud/services/server/reconcile_test.go @@ -0,0 +1,646 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package server_test + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "github.com/stackitcloud/stackit-sdk-go/core/config" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +const ( + testProjectID = "00000000-0000-0000-0000-000000000000" + testRegion = "eu01" + testServerID = "33333333-3333-4333-8333-333333333333" + testOtherServerID = "44444444-4444-4444-8444-444444444444" + testNetworkID = "11111111-1111-4111-8111-111111111111" + testImageID = "22222222-2222-4222-8222-222222222222" + testSecurityGroupID = "55555555-5555-4555-8555-555555555555" + testBoolTrue = "true" +) + +type testScope struct { + projectID string + region string + iaasClient *iaas.APIClient + spec server.ServerSpec +} + +func (s *testScope) ProjectID() string { + return s.projectID +} + +func (s *testScope) Region() string { + return s.region +} + +func (s *testScope) IaaSClient() *iaas.APIClient { + return s.iaasClient +} + +func (s *testScope) ServerSpec() server.ServerSpec { + return s.spec +} + +func newTestIaaSClient(t *testing.T, handler http.Handler) *iaas.APIClient { + t.Helper() + + srv := httptest.NewServer(handler) + t.Cleanup(srv.Close) + + iaasClient, err := iaas.NewAPIClient( + config.WithoutAuthentication(), + config.WithEndpoint(srv.URL), + ) + if err != nil { + t.Fatalf("iaas.NewAPIClient() error = %v", err) + } + return iaasClient +} + +func newTestService(t *testing.T, spec server.ServerSpec, handler http.Handler) *server.Service { + t.Helper() + + return server.New(&testScope{ + projectID: testProjectID, + region: testRegion, + iaasClient: newTestIaaSClient(t, handler), + spec: spec, + }) +} + +func writeJSON(t *testing.T, w http.ResponseWriter, value any) { + t.Helper() + w.Header().Set("Content-Type", "application/json") + if err := json.NewEncoder(w).Encode(value); err != nil { + t.Fatalf("encode response body: %v", err) + } +} + +func readJSON(t *testing.T, r *http.Request) map[string]any { + t.Helper() + var out map[string]any + if err := json.NewDecoder(r.Body).Decode(&out); err != nil { + t.Fatalf("decode request body: %v", err) + } + return out +} + +func assertStringField(t *testing.T, m map[string]any, key, want string) { + t.Helper() + if got := lookup(m, key); got != want { + t.Fatalf("%s = %#v, want %q in %#v", key, got, want, m) + } +} + +func assertBoolField(t *testing.T, m map[string]any, key string, want bool) { + t.Helper() + if got := lookup(m, key); got != want { + t.Fatalf("%s = %#v, want %t in %#v", key, got, want, m) + } +} + +func assertFieldAbsent(t *testing.T, payload map[string]any, key string) { + t.Helper() + if _, ok := payload[key]; ok { + t.Fatalf("%s present in payload, want absent: %#v", key, payload[key]) + } +} + +func assertNestedStringField(t *testing.T, m map[string]any, path []string, want string) { + t.Helper() + if got := nestedValue(t, m, path); got != want { + t.Fatalf("%s = %#v, want %q in %#v", strings.Join(path, "."), got, want, m) + } +} + +func assertNestedNumberField(t *testing.T, m map[string]any, path []string, want float64) { + t.Helper() + if got := nestedValue(t, m, path); got != want { + t.Fatalf("%s = %#v, want %v in %#v", strings.Join(path, "."), got, want, m) + } +} + +func nestedValue(t *testing.T, m map[string]any, path []string) any { + t.Helper() + + var current any = m + for _, part := range path { + switch typed := current.(type) { + case map[string]any: + current = lookup(typed, part) + default: + t.Fatalf("path element %q cannot descend into %#v", part, typed) + } + } + return current +} + +func lookup(m map[string]any, key string) any { + for _, candidate := range []string{ + key, + strings.ToUpper(key[:1]) + key[1:], + } { + if value, ok := m[candidate]; ok { + return value + } + } + return nil +} + +func TestServiceReconcile(t *testing.T) { + t.Run("creates server with bootVolume and expected payload when not found", func(t *testing.T) { + var ( + createPayload map[string]any + recordedServer *server.Server + wasCreated bool + ) + spec := server.ServerSpec{ + Name: "node-0", + MachineType: "c2i.2", + ImageID: testImageID, + AvailabilityZone: "eu01-1", + SSHKeyName: "default", + NetworkID: testNetworkID, + SecurityGroups: []string{testSecurityGroupID}, + UserData: []byte("#cloud-config\n"), + RootVolume: server.RootVolume{ + SizeGiB: 50, + PerformanceClass: "storage_premium_perf6", + DeleteOnTermination: true, + }, + Tags: map[string]string{"cluster": "test"}, + SetServer: func(srv *server.Server, created bool) { + recordedServer = srv + wasCreated = created + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers"): + if got := r.URL.Query().Get("label_selector"); got != "cluster=test" { + t.Fatalf("label_selector = %q, want cluster=test", got) + } + if got := r.URL.Query().Get("details"); got != testBoolTrue { + t.Fatalf("details = %q, want true", got) + } + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/servers"): + createPayload = readJSON(t, r) + writeJSON(t, w, map[string]any{ + "id": testServerID, + "machineType": "c2i.2", + "name": "node-0", + "status": "ACTIVE", + "availabilityZone": "eu01-1", + }) + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID+"/nics"): + writeJSON(t, w, map[string]any{ + "items": []any{ + map[string]any{"ipv4": "10.0.0.10", "ipv6": "fd00::10"}, + }, + }) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if !wasCreated { + t.Fatal("SetServer created = false, want true") + } + if recordedServer == nil || recordedServer.ID != testServerID || recordedServer.Name != "node-0" || recordedServer.State != "ACTIVE" { + t.Fatalf("recordedServer = %#v", recordedServer) + } + if len(recordedServer.Addresses) != 2 { + t.Fatalf("recordedServer.Addresses = %#v, want 2 addresses", recordedServer.Addresses) + } + + assertStringField(t, createPayload, "name", "node-0") + assertStringField(t, createPayload, "machineType", "c2i.2") + assertFieldAbsent(t, createPayload, "imageId") + assertStringField(t, createPayload, "availabilityZone", "eu01-1") + assertStringField(t, createPayload, "keypairName", "default") + assertStringField(t, createPayload, "userData", "I2Nsb3VkLWNvbmZpZwo=") + assertBoolField(t, createPayload, "configDrive", true) + assertNestedStringField(t, createPayload, []string{"labels", "cluster"}, "test") + assertNestedStringField(t, createPayload, []string{"networking", "networkId"}, testNetworkID) + assertNestedStringField(t, createPayload, []string{"bootVolume", "performanceClass"}, "storage_premium_perf6") + assertNestedStringField(t, createPayload, []string{"bootVolume", "source", "id"}, testImageID) + assertNestedStringField(t, createPayload, []string{"bootVolume", "source", "type"}, "image") + assertNestedNumberField(t, createPayload, []string{"bootVolume", "size"}, 50) + }) + + t.Run("creates server with imageId when rootVolume size and performanceClass are unset", func(t *testing.T) { + var createPayload map[string]any + spec := server.ServerSpec{ + Name: "node-0", + MachineType: "c2i.2", + ImageID: testImageID, + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers"): + writeJSON(t, w, map[string]any{"items": []any{}}) + case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/servers"): + createPayload = readJSON(t, r) + writeJSON(t, w, map[string]any{ + "id": testServerID, + "machineType": "c2i.2", + "name": "node-0", + "status": "ACTIVE", + }) + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID+"/nics"): + writeJSON(t, w, map[string]any{"items": []any{}}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + assertStringField(t, createPayload, "imageId", testImageID) + assertFieldAbsent(t, createPayload, "bootVolume") + }) +} + +func TestServiceReconcileReuseAndErrors(t *testing.T) { + t.Run("reuses existing server by ID without listing by tags or creating duplicate", func(t *testing.T) { + var ( + recordedServer *server.Server + wasCreated = true + ) + spec := server.ServerSpec{ + ID: testServerID, + Name: "node-0", + MachineType: "c2i.2", + ImageID: testImageID, + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + SetServer: func(srv *server.Server, created bool) { + recordedServer = srv + wasCreated = created + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID): + writeJSON(t, w, map[string]any{ + "id": testServerID, + "machineType": "c2i.2", + "name": "node-0", + "status": "ACTIVE", + }) + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID+"/nics"): + writeJSON(t, w, map[string]any{"items": []any{}}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if wasCreated { + t.Fatal("SetServer created = true, want false") + } + if recordedServer == nil || recordedServer.ID != testServerID { + t.Fatalf("recordedServer = %#v, want ID %s", recordedServer, testServerID) + } + }) + + t.Run("reuses existing server found by tags without creating duplicate", func(t *testing.T) { + var ( + recordedServer *server.Server + wasCreated = true + ) + spec := server.ServerSpec{ + Name: "node-0", + MachineType: "c2i.2", + ImageID: testImageID, + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + SetServer: func(srv *server.Server, created bool) { + recordedServer = srv + wasCreated = created + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{ + "id": testServerID, + "machineType": "c2i.2", + "name": "node-0", + "status": "ACTIVE", + "labels": map[string]any{"cluster": "test"}, + }, + }}) + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID+"/nics"): + writeJSON(t, w, map[string]any{"items": []any{}}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Reconcile(context.Background()); err != nil { + t.Fatalf("Reconcile() error = %v", err) + } + if wasCreated { + t.Fatal("SetServer created = true, want false") + } + if recordedServer == nil || recordedServer.ID != testServerID { + t.Fatalf("recordedServer = %#v, want ID %s", recordedServer, testServerID) + } + }) + + t.Run("returns ErrServerGone when DisallowRecreate is true and server is missing", func(t *testing.T) { + spec := server.ServerSpec{ + ID: testServerID, + Name: "node-0", + MachineType: "c2i.2", + ImageID: testImageID, + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + DisallowRecreate: true, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID): + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers"): + writeJSON(t, w, map[string]any{"items": []any{}}) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + err := svc.Reconcile(context.Background()) + if !server.IsServerGone(err) { + t.Fatalf("Reconcile() error = %v, want ErrServerGone", err) + } + }) + + t.Run("returns ErrConflict when multiple servers match tags", func(t *testing.T) { + spec := server.ServerSpec{ + Name: "node-0", + MachineType: "c2i.2", + ImageID: testImageID, + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers") { + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testServerID, "name": "node-0", "machineType": "c2i.2", "labels": map[string]any{"cluster": "test"}}, + map[string]any{"id": testOtherServerID, "name": "node-1", "machineType": "c2i.2", "labels": map[string]any{"cluster": "test"}}, + }}) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrConflict) { + t.Fatalf("Reconcile() error = %v, want ErrConflict", err) + } + }) +} + +func TestServiceReconcileValidation(t *testing.T) { + tests := []struct { + name string + spec server.ServerSpec + }{ + { + name: "missing name", + spec: server.ServerSpec{ + ImageID: testImageID, + MachineType: "c2i.2", + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "missing image ID", + spec: server.ServerSpec{ + Name: "node-0", + MachineType: "c2i.2", + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "missing machine type", + spec: server.ServerSpec{ + Name: "node-0", + ImageID: testImageID, + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "missing SSH key name when required", + spec: server.ServerSpec{ + Name: "node-0", + ImageID: testImageID, + MachineType: "c2i.2", + RequireSSHKey: true, + NetworkID: testNetworkID, + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "missing network ID", + spec: server.ServerSpec{ + Name: "node-0", + ImageID: testImageID, + MachineType: "c2i.2", + Tags: map[string]string{"cluster": "test"}, + }, + }, + { + name: "missing tags", + spec: server.ServerSpec{ + Name: "node-0", + ImageID: testImageID, + MachineType: "c2i.2", + NetworkID: testNetworkID, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + svc := newTestService(t, tt.spec, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + err := svc.Reconcile(context.Background()) + if !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Reconcile() error = %v, want ErrInvalidInput", err) + } + }) + } +} + +func TestServiceDelete(t *testing.T) { + t.Run("deletes server by ID when provided and clears state via SetServer", func(t *testing.T) { + var ( + deletedID string + setServerCalls int + clearedServer *server.Server + clearedCreated = true + ) + spec := server.ServerSpec{ + ID: testServerID, + SetServer: func(srv *server.Server, created bool) { + setServerCalls++ + clearedServer = srv + clearedCreated = created + }, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID) { + deletedID = testServerID + w.WriteHeader(http.StatusNoContent) + return + } + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if deletedID != testServerID { + t.Fatalf("deletedID = %q, want %q", deletedID, testServerID) + } + if setServerCalls != 1 { + t.Fatalf("SetServer calls = %d, want 1", setServerCalls) + } + if clearedServer != nil || clearedCreated { + t.Fatalf("SetServer called with (%#v, %v), want (nil, false)", clearedServer, clearedCreated) + } + }) + + t.Run("falls back to tag lookup when ID is empty and deletes all matching servers", func(t *testing.T) { + var deletedIDs []string + spec := server.ServerSpec{ + Tags: map[string]string{"cluster": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testServerID, "name": "node-0", "machineType": "c2i.2", "labels": map[string]any{"cluster": "test"}}, + map[string]any{"id": testOtherServerID, "name": "node-1", "machineType": "c2i.2", "labels": map[string]any{"cluster": "test"}}, + map[string]any{"id": "ignored-id", "name": "other", "machineType": "c2i.2", "labels": map[string]any{"cluster": "other"}}, + }}) + case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID): + deletedIDs = append(deletedIDs, testServerID) + w.WriteHeader(http.StatusNoContent) + case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/servers/"+testOtherServerID): + deletedIDs = append(deletedIDs, testOtherServerID) + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if len(deletedIDs) != 2 || deletedIDs[0] != testServerID || deletedIDs[1] != testOtherServerID { + t.Fatalf("deletedIDs = %v, want [%s %s]", deletedIDs, testServerID, testOtherServerID) + } + }) + + t.Run("falls back to tag lookup when recorded ID no longer exists", func(t *testing.T) { + var deletedID string + spec := server.ServerSpec{ + ID: testOtherServerID, + Tags: map[string]string{"cluster": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch { + case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/servers/"+testOtherServerID): + w.WriteHeader(http.StatusNotFound) + writeJSON(t, w, map[string]any{"message": "not found"}) + case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/servers"): + writeJSON(t, w, map[string]any{"items": []any{ + map[string]any{"id": testServerID, "name": "node-0", "machineType": "c2i.2", "labels": map[string]any{"cluster": "test"}}, + }}) + case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/servers/"+testServerID): + deletedID = testServerID + w.WriteHeader(http.StatusNoContent) + default: + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + } + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v", err) + } + if deletedID != testServerID { + t.Fatalf("deletedID = %q, want %q", deletedID, testServerID) + } + }) + + t.Run("succeeds when server is not found", func(t *testing.T) { + spec := server.ServerSpec{ + Tags: map[string]string{"cluster": "test"}, + } + + svc := newTestService(t, spec, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + writeJSON(t, w, map[string]any{"items": []any{}}) + })) + + if err := svc.Delete(context.Background()); err != nil { + t.Fatalf("Delete() error = %v, want nil", err) + } + }) + + t.Run("returns ErrInvalidInput when both ID and tags are empty", func(t *testing.T) { + svc := newTestService(t, server.ServerSpec{}, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) { + t.Fatalf("unexpected request: %s %s", r.Method, r.URL.String()) + })) + + if err := svc.Delete(context.Background()); !errors.Is(err, shared.ErrInvalidInput) { + t.Fatalf("Delete() error = %v, want ErrInvalidInput", err) + } + }) +} diff --git a/cloud/services/server/service.go b/cloud/services/server/service.go new file mode 100644 index 0000000..5fdcd1b --- /dev/null +++ b/cloud/services/server/service.go @@ -0,0 +1,85 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package server + +import ( + "errors" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" +) + +// errServerGone indicates that an already-provisioned server is missing in +// STACKIT and must not be recreated with stale bootstrap data. +var errServerGone = errors.New("server gone") + +// IsServerGone reports whether err wraps errServerGone. +func IsServerGone(err error) bool { + return errors.Is(err, errServerGone) +} + +// Server describes a STACKIT compute instance in provider-neutral terms. +type Server struct { + ID string + Name string + State string + PowerStatus string + AvailabilityZone string + Addresses []Address +} + +// Address is an IP or DNS endpoint of a Server. +type Address struct { + Type string + Address string +} + +// RootVolume describes the root disk of a VM. +type RootVolume struct { + SizeGiB int + PerformanceClass string + DeleteOnTermination bool +} + +// ServerSpec describes the desired state of a STACKIT server. +type ServerSpec struct { + ID string + Name string + ImageID string + MachineType string + AvailabilityZone string + SSHKeyName string + RequireSSHKey bool + NetworkID string + SecurityGroups []string + UserData []byte + Tags map[string]string + RootVolume RootVolume + DisallowRecreate bool + SetServer func(server *Server, created bool) +} + +// Scope is an interface that provides scope data needed for server reconciliation. +type Scope interface { + shared.IaaSClientScope + ServerSpec() ServerSpec +} + +// Service implements server reconciler. +type Service struct { + scope Scope +} + +// New returns Service from given scope. +func New(scope Scope) *Service { + return &Service{ + scope: scope, + } +} diff --git a/controller/server_state.go b/cloud/services/server/state.go similarity index 90% rename from controller/server_state.go rename to cloud/services/server/state.go index aaa18e0..8204854 100644 --- a/controller/server_state.go +++ b/cloud/services/server/state.go @@ -8,11 +8,11 @@ You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 */ -package controller +package server import "fmt" -type serverStateInfo struct { +type stateInfo struct { reason string description string // warn marks states that do not resolve on their own. Their reason must @@ -24,7 +24,7 @@ type serverStateInfo struct { // serverStates maps the documented STACKIT server states. // https://docs.api.stackit.cloud/documentation/iaas/version/v2#tag/Servers/operation/V2GetServer // https://github.com/stackitcloud/stackit-sdk-go/blob/services/iaas/v1.14.5/services/iaas/v2api/model_server.go#L63-L64 -var serverStates = map[string]serverStateInfo{ +var serverStates = map[string]stateInfo{ "ACTIVE": {"InstanceActive", "server is active", false}, "BACKING-UP": {"InstanceBusy", "server is temporarily unavailable", false}, "CREATING": {"InstanceStarting", "server is starting", false}, @@ -51,16 +51,16 @@ var serverStates = map[string]serverStateInfo{ "UPDATING": {"InstanceBusy", "server is temporarily unavailable", false}, } -// serverStateCondition maps a server state and power status to a condition +// StateCondition maps a server state and power status to a condition // reason and message. ready is true when the server can be used. -func serverStateCondition(state, powerStatus string) (ready bool, reason, message string, warn bool) { +func StateCondition(state, powerStatus string) (ready bool, reason, message string, warn bool) { if state == "" { ready = true return } info, ok := serverStates[state] if !ok { - info = serverStateInfo{"InstanceNotActive", "server is not active", false} + info = stateInfo{"InstanceNotActive", "server is not active", false} } ready, warn, reason, description := state == "ACTIVE", info.warn, info.reason, info.description if state == "ACTIVE" { diff --git a/cloud/services/server/state_test.go b/cloud/services/server/state_test.go new file mode 100644 index 0000000..879cf0c --- /dev/null +++ b/cloud/services/server/state_test.go @@ -0,0 +1,201 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package server_test + +import ( + "testing" + + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" +) + +func TestStateCondition(t *testing.T) { + tests := []struct { + name string + state string + powerStatus string + wantReady bool + wantReason string + wantMessage string + wantWarn bool + }{ + { + name: "active and running", + state: "ACTIVE", + powerStatus: "RUNNING", + wantReady: true, + wantReason: "InstanceActive", + wantMessage: "server is active (state ACTIVE, power status RUNNING)", + wantWarn: false, + }, + { + name: "unknown state", + state: "", + powerStatus: "", + wantReady: true, + wantReason: "", + wantMessage: "", + wantWarn: false, + }, + { + name: "active but crashed", + state: "ACTIVE", + powerStatus: "CRASHED", + wantReady: false, + wantReason: "InstanceCrashed", + wantMessage: "server crashed (state ACTIVE, power status CRASHED)", + wantWarn: true, + }, + { + name: "active with power error", + state: "ACTIVE", + powerStatus: "ERROR", + wantReady: false, + wantReason: "InstancePowerError", + wantMessage: "server power error (state ACTIVE, power status ERROR)", + wantWarn: true, + }, + { + name: "creating", + state: "CREATING", + powerStatus: "", + wantReady: false, + wantReason: "InstanceStarting", + wantMessage: "server is starting (state CREATING)", + wantWarn: false, + }, + { + name: "rebooting", + state: "REBOOTING", + powerStatus: "RUNNING", + wantReady: false, + wantReason: "InstanceBusy", + wantMessage: "server is temporarily unavailable (state REBOOTING, power status RUNNING)", + wantWarn: false, + }, + { + name: "stopping", + state: "STOPPING", + powerStatus: "RUNNING", + wantReady: false, + wantReason: "InstanceStopping", + wantMessage: "server is stopping (state STOPPING, power status RUNNING)", + wantWarn: false, + }, + { + name: "stopped", + state: "INACTIVE", + powerStatus: "STOPPED", + wantReady: false, + wantReason: "InstanceStopped", + wantMessage: "server is stopped (state INACTIVE, power status STOPPED)", + wantWarn: true, + }, + { + name: "deallocating", + state: "DEALLOCATING", + powerStatus: "STOPPED", + wantReady: false, + wantReason: "InstanceDeallocating", + wantMessage: "server is being deallocated (state DEALLOCATING, power status STOPPED)", + wantWarn: false, + }, + { + name: "deallocated", + state: "DEALLOCATED", + powerStatus: "STOPPED", + wantReady: false, + wantReason: "InstanceDeallocated", + wantMessage: "server is deallocated (state DEALLOCATED, power status STOPPED)", + wantWarn: true, + }, + { + name: "paused", + state: "PAUSED", + powerStatus: "", + wantReady: false, + wantReason: "InstancePaused", + wantMessage: "server is paused (state PAUSED)", + wantWarn: true, + }, + { + name: "entering rescue", + state: "RESCUING", + powerStatus: "", + wantReady: false, + wantReason: "InstanceEnteringRescue", + wantMessage: "server is entering rescue mode (state RESCUING)", + wantWarn: false, + }, + { + name: "leaving rescue", + state: "UNRESCUING", + powerStatus: "", + wantReady: false, + wantReason: "InstanceLeavingRescue", + wantMessage: "server is leaving rescue mode (state UNRESCUING)", + wantWarn: false, + }, + { + name: "rescue", + state: "RESCUE", + powerStatus: "RUNNING", + wantReady: false, + wantReason: "InstanceInRescue", + wantMessage: "server is in rescue mode (state RESCUE, power status RUNNING)", + wantWarn: true, + }, + { + name: "deleting", + state: "DELETING", + powerStatus: "", + wantReady: false, + wantReason: "InstanceDeleting", + wantMessage: "server is being deleted (state DELETING)", + wantWarn: false, + }, + { + name: "error", + state: "ERROR", + powerStatus: "ERROR", + wantReady: false, + wantReason: "InstanceFailed", + wantMessage: "server failed (state ERROR, power status ERROR)", + wantWarn: true, + }, + { + name: "undocumented state", + state: "SOMETHING", + powerStatus: "", + wantReady: false, + wantReason: "InstanceNotActive", + wantMessage: "server is not active (state SOMETHING)", + wantWarn: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ready, reason, message, warn := server.StateCondition(tt.state, tt.powerStatus) + if ready != tt.wantReady { + t.Errorf("StateCondition(%q, %q) ready = %v, want %v", tt.state, tt.powerStatus, ready, tt.wantReady) + } + if reason != tt.wantReason { + t.Errorf("StateCondition(%q, %q) reason = %q, want %q", tt.state, tt.powerStatus, reason, tt.wantReason) + } + if message != tt.wantMessage { + t.Errorf("StateCondition(%q, %q) message = %q, want %q", tt.state, tt.powerStatus, message, tt.wantMessage) + } + if warn != tt.wantWarn { + t.Errorf("StateCondition(%q, %q) warn = %v, want %v", tt.state, tt.powerStatus, warn, tt.wantWarn) + } + }) + } +} diff --git a/cloud/errors.go b/cloud/services/shared/errors.go similarity index 98% rename from cloud/errors.go rename to cloud/services/shared/errors.go index 1aeaa68..73ecf9b 100644 --- a/cloud/errors.go +++ b/cloud/services/shared/errors.go @@ -8,7 +8,7 @@ You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 */ -package cloud +package shared import "errors" diff --git a/cloud/services/shared/errors_test.go b/cloud/services/shared/errors_test.go new file mode 100644 index 0000000..1add3ba --- /dev/null +++ b/cloud/services/shared/errors_test.go @@ -0,0 +1,369 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package shared + +import ( + "context" + "fmt" + "testing" +) + +func TestErrorClassification(t *testing.T) { + if !IsNotFound(fmt.Errorf("wrapped: %w", ErrNotFound)) { + t.Fatal("IsNotFound() = false, want true") + } + if !IsUnauthorized(fmt.Errorf("wrapped: %w", ErrUnauthorized)) { + t.Fatal("IsUnauthorized() = false, want true") + } + if !IsInvalidInput(fmt.Errorf("wrapped: %w", ErrInvalidInput)) { + t.Fatal("IsInvalidInput() = false, want true") + } + if !IsConflict(fmt.Errorf("wrapped: %w", ErrConflict)) { + t.Fatal("IsConflict() = false, want true") + } + if !IsTransient(fmt.Errorf("wrapped: %w", ErrTransient)) { + t.Fatal("IsTransient() = false, want true") + } +} + +func TestIsRetryable(t *testing.T) { + tests := []struct { + name string + err error + want bool + }{ + {name: "conflict", err: ErrConflict, want: true}, + {name: "transient", err: ErrTransient, want: true}, + {name: "not found", err: ErrNotFound, want: false}, + {name: "unauthorized", err: ErrUnauthorized, want: false}, + {name: "invalid input", err: ErrInvalidInput, want: false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := IsRetryable(tt.err); got != tt.want { + t.Fatalf("IsRetryable() = %t, want %t", got, tt.want) + } + }) + } +} + +func TestFindByTags(t *testing.T) { + ctx := context.Background() + tags := map[string]string{"cluster": "test"} + + t.Run("propagates error from listByTags", func(t *testing.T) { + _, err := FindByTags(ctx, tags, func(context.Context, map[string]string) ([]string, error) { + return nil, ErrTransient + }, "server", "servers") + if !IsTransient(err) { + t.Fatalf("FindByTags() error = %v, want ErrTransient", err) + } + }) + + t.Run("returns ErrNotFound when empty", func(t *testing.T) { + _, err := FindByTags(ctx, tags, func(context.Context, map[string]string) ([]string, error) { + return nil, nil + }, "server", "servers") + if !IsNotFound(err) { + t.Fatalf("FindByTags() error = %v, want ErrNotFound", err) + } + }) + + t.Run("returns ErrConflict when multiple", func(t *testing.T) { + _, err := FindByTags(ctx, tags, func(context.Context, map[string]string) ([]string, error) { + return []string{"a", "b"}, nil + }, "server", "servers") + if !IsConflict(err) { + t.Fatalf("FindByTags() error = %v, want ErrConflict", err) + } + }) + + t.Run("returns single element", func(t *testing.T) { + got, err := FindByTags(ctx, tags, func(context.Context, map[string]string) ([]string, error) { + return []string{"a"}, nil + }, "server", "servers") + if err != nil { + t.Fatalf("FindByTags() error = %v", err) + } + if got != "a" { + t.Fatalf("FindByTags() = %q, want %q", got, "a") + } + }) +} + +func TestListIDsByTags(t *testing.T) { + ctx := context.Background() + tags := map[string]string{"cluster": "test"} + type item struct{ id string } + + t.Run("propagates error from listByTags", func(t *testing.T) { + _, err := ListIDsByTags(ctx, tags, func(context.Context, map[string]string) ([]item, error) { + return nil, ErrTransient + }, func(i item) string { return i.id }) + if !IsTransient(err) { + t.Fatalf("ListIDsByTags() error = %v, want ErrTransient", err) + } + }) + + t.Run("collects non-empty IDs", func(t *testing.T) { + ids, err := ListIDsByTags(ctx, tags, func(context.Context, map[string]string) ([]item, error) { + return []item{{id: "id-1"}, {id: ""}, {id: "id-2"}}, nil + }, func(i item) string { return i.id }) + if err != nil { + t.Fatalf("ListIDsByTags() error = %v", err) + } + if len(ids) != 2 || ids[0] != "id-1" || ids[1] != "id-2" { + t.Fatalf("ListIDsByTags() = %v, want [id-1 id-2]", ids) + } + }) +} + +type fakeLabeledItem[V any] struct { + id string + labels map[string]V +} + +func (f *fakeLabeledItem[V]) GetLabels() map[string]V { + return f.labels +} + +func TestListByTags(t *testing.T) { + tags := map[string]string{"cluster": "c1", "role": "bastion"} + + t.Run("returns ErrInvalidInput when tags are empty", func(t *testing.T) { + listCalled := false + _, err := ListByTags(nil, func(string) ([]fakeLabeledItem[any], error) { + listCalled = true + return nil, nil + }, func(item *fakeLabeledItem[any]) string { return item.id }) + if !IsInvalidInput(err) { + t.Fatalf("ListByTags() error = %v, want ErrInvalidInput", err) + } + if listCalled { + t.Fatal("list should not be called when tags are empty") + } + }) + + t.Run("propagates error from list", func(t *testing.T) { + _, err := ListByTags(tags, func(string) ([]fakeLabeledItem[any], error) { + return nil, ErrTransient + }, func(item *fakeLabeledItem[any]) string { return item.id }) + if !IsTransient(err) { + t.Fatalf("ListByTags() error = %v, want ErrTransient", err) + } + }) + + t.Run("passes label selector and filters items matching all tags", func(t *testing.T) { + var gotSelector string + got, err := ListByTags(tags, func(selector string) ([]fakeLabeledItem[any], error) { + gotSelector = selector + return []fakeLabeledItem[any]{ + {id: "match", labels: map[string]any{"cluster": "c1", "role": "bastion", "extra": "ok"}}, + {id: "partial", labels: map[string]any{"cluster": "c1"}}, + {id: "other", labels: map[string]any{"cluster": "c2", "role": "bastion"}}, + }, nil + }, func(item *fakeLabeledItem[any]) string { return item.id }) + if err != nil { + t.Fatalf("ListByTags() error = %v", err) + } + if gotSelector != "cluster=c1,role=bastion" && gotSelector != "role=bastion,cluster=c1" { + t.Fatalf("selector = %q, want both tag pairs", gotSelector) + } + if len(got) != 1 || got[0] != "match" { + t.Fatalf("ListByTags() = %v, want [match]", got) + } + }) + + t.Run("filters string-labeled items matching all tags", func(t *testing.T) { + got, err := ListByTags(tags, func(string) ([]fakeLabeledItem[string], error) { + return []fakeLabeledItem[string]{ + {id: "match", labels: map[string]string{"cluster": "c1", "role": "bastion"}}, + {id: "partial", labels: map[string]string{"cluster": "c1"}}, + }, nil + }, func(item *fakeLabeledItem[string]) string { return item.id }) + if err != nil { + t.Fatalf("ListByTags() error = %v", err) + } + if len(got) != 1 || got[0] != "match" { + t.Fatalf("ListByTags() = %v, want [match]", got) + } + }) +} + +func TestResolveExisting(t *testing.T) { + const ( + testID1 = "id-1" + testByTags = "by-tags" + ) + ctx := context.Background() + tags := map[string]string{"cluster": "test"} + + t.Run("returns item by ID without calling findByTags", func(t *testing.T) { + findByTagsCalled := false + got, err := ResolveExisting( + ctx, + testID1, + tags, + func(_ context.Context, id string) (string, error) { + return "found-" + id, nil + }, + func(_ context.Context, _ map[string]string) (string, error) { + findByTagsCalled = true + return testByTags, nil + }, + IsNotFound, + ) + if err != nil { + t.Fatalf("ResolveExisting() error = %v", err) + } + if got != "found-id-1" { + t.Fatalf("ResolveExisting() = %q, want %q", got, "found-id-1") + } + if findByTagsCalled { + t.Fatal("findByTags should not be called when getByID succeeds") + } + }) + + t.Run("falls back to findByTags when getByID returns NotFound", func(t *testing.T) { + got, err := ResolveExisting( + ctx, + "stale-id", + tags, + func(_ context.Context, _ string) (string, error) { + return "", ErrNotFound + }, + func(_ context.Context, _ map[string]string) (string, error) { + return testByTags, nil + }, + IsNotFound, + ) + if err != nil { + t.Fatalf("ResolveExisting() error = %v", err) + } + if got != testByTags { + t.Fatalf("ResolveExisting() = %q, want %q", got, testByTags) + } + }) + + t.Run("returns zero value and nil error when both ID and tag lookup return NotFound", func(t *testing.T) { + got, err := ResolveExisting( + ctx, + "stale-id", + tags, + func(_ context.Context, _ string) (string, error) { + return "", ErrNotFound + }, + func(_ context.Context, _ map[string]string) (string, error) { + return "", ErrNotFound + }, + IsNotFound, + ) + if err != nil { + t.Fatalf("ResolveExisting() error = %v, want nil", err) + } + if got != "" { + t.Fatalf("ResolveExisting() = %q, want empty", got) + } + }) + + t.Run("propagates non-ignorable error from getByID", func(t *testing.T) { + _, err := ResolveExisting( + ctx, + testID1, + tags, + func(_ context.Context, _ string) (string, error) { + return "", ErrTransient + }, + func(_ context.Context, _ map[string]string) (string, error) { + return testByTags, nil + }, + IsNotFound, + ) + if !IsTransient(err) { + t.Fatalf("ResolveExisting() error = %v, want ErrTransient", err) + } + }) +} + +func TestDeleteByIDOrTags(t *testing.T) { + const testID1 = "id-1" + ctx := context.Background() + tags := map[string]string{"cluster": "test"} + + t.Run("deletes by ID when found without listing by tags", func(t *testing.T) { + listCalled := false + deletedIDs, err := DeleteByIDOrTags( + ctx, + testID1, + tags, + func(_ context.Context, id string) (bool, error) { + return id == testID1, nil + }, + func(_ context.Context, _ map[string]string) ([]string, error) { + listCalled = true + return []string{"id-2"}, nil + }, + ) + if err != nil { + t.Fatalf("DeleteByIDOrTags() error = %v", err) + } + if len(deletedIDs) != 1 || deletedIDs[0] != testID1 { + t.Fatalf("DeleteByIDOrTags() = %v, want [id-1]", deletedIDs) + } + if listCalled { + t.Fatal("listIDsByTags should not be called when deleteByID deletes spec.ID") + } + }) + + t.Run("falls back to tag lookup when spec.ID is already absent", func(t *testing.T) { + deletedIDs, err := DeleteByIDOrTags( + ctx, + "stale-id", + tags, + func(_ context.Context, id string) (bool, error) { + return id != "stale-id", nil + }, + func(_ context.Context, _ map[string]string) ([]string, error) { + return []string{testID1, "id-2"}, nil + }, + ) + if err != nil { + t.Fatalf("DeleteByIDOrTags() error = %v", err) + } + if len(deletedIDs) != 2 || deletedIDs[0] != testID1 || deletedIDs[1] != "id-2" { + t.Fatalf("DeleteByIDOrTags() = %v, want [id-1 id-2]", deletedIDs) + } + }) + + t.Run("continues deleting remaining tag matches on partial error", func(t *testing.T) { + deletedIDs, err := DeleteByIDOrTags( + ctx, + "", + tags, + func(_ context.Context, id string) (bool, error) { + if id == "bad-id" { + return false, ErrTransient + } + return true, nil + }, + func(_ context.Context, _ map[string]string) ([]string, error) { + return []string{"bad-id", "good-id"}, nil + }, + ) + if !IsTransient(err) { + t.Fatalf("DeleteByIDOrTags() error = %v, want ErrTransient", err) + } + if len(deletedIDs) != 1 || deletedIDs[0] != "good-id" { + t.Fatalf("DeleteByIDOrTags() = %v, want [good-id]", deletedIDs) + } + }) +} diff --git a/cloud/services/shared/utils.go b/cloud/services/shared/utils.go new file mode 100644 index 0000000..79e0464 --- /dev/null +++ b/cloud/services/shared/utils.go @@ -0,0 +1,262 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package shared + +import ( + "context" + "errors" + "fmt" + "net/http" + "strings" + + "github.com/stackitcloud/stackit-sdk-go/core/oapierror" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + lb "github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/v2api" +) + +// IaaSClientScope is an interface that provides the IaaS client and target scope for IaaS operations. +type IaaSClientScope interface { + ProjectID() string + Region() string + IaaSClient() *iaas.APIClient +} + +// LoadBalancerClientScope is an interface that provides the LoadBalancer client and target scope for load balancer operations. +type LoadBalancerClientScope interface { + ProjectID() string + Region() string + LoadBalancerClient() *lb.APIClient +} + +// ListByTags validates that tags are non-empty, lists SDK items using the tag label selector, +// filters items whose labels contain all tags, and maps each matching item via convert. +func ListByTags[T any, Out any]( + tags map[string]string, + list func(labelSelector string) ([]T, error), + convert func(*T) Out, +) ([]Out, error) { + if len(tags) == 0 { + return nil, fmt.Errorf("%w: empty tag selector", ErrInvalidInput) + } + items, err := list(labelSelector(tags)) + if err != nil { + return nil, err + } + matched := []Out{} + for _, item := range items { + if itemContainsTags(&item, tags) { + matched = append(matched, convert(&item)) + } + } + return matched, nil +} + +// ListServersByTags lists STACKIT servers matching the given tag selector. +func ListServersByTags(ctx context.Context, scope IaaSClientScope, tags map[string]string) ([]*iaas.Server, error) { + return ListByTags(tags, func(selector string) ([]iaas.Server, error) { + resp, err := scope.IaaSClient().DefaultAPI.ListServers(ctx, scope.ProjectID(), scope.Region()). + LabelSelector(selector). + Details(true). + Execute() + if err != nil { + return nil, ClassifySDKError("list servers", err) + } + return resp.GetItems(), nil + }, func(srv *iaas.Server) *iaas.Server { + return srv + }) +} + +// ListServerIDsByTags lists the IDs of STACKIT servers matching the given tag selector. +func ListServerIDsByTags(ctx context.Context, scope IaaSClientScope, tags map[string]string) ([]string, error) { + return ListIDsByTags(ctx, tags, func(ctx context.Context, tags map[string]string) ([]*iaas.Server, error) { + return ListServersByTags(ctx, scope, tags) + }, (*iaas.Server).GetId) +} + +// ListIDsByTags lists resources by tags and collects their non-empty IDs. +func ListIDsByTags[T any]( + ctx context.Context, + tags map[string]string, + listByTags func(context.Context, map[string]string) ([]T, error), + getID func(T) string, +) ([]string, error) { + items, err := listByTags(ctx, tags) + if err != nil { + return nil, err + } + ids := make([]string, 0, len(items)) + for _, item := range items { + if id := getID(item); id != "" { + ids = append(ids, id) + } + } + return ids, nil +} + +// FindByTags lists resources by tags and returns the single matching item, or ErrNotFound if empty, or ErrConflict if more than one. +func FindByTags[T any]( + ctx context.Context, + tags map[string]string, + listByTags func(context.Context, map[string]string) ([]T, error), + singular, plural string, +) (T, error) { + var zero T + matched, err := listByTags(ctx, tags) + if err != nil { + return zero, err + } + if len(matched) == 0 { + return zero, fmt.Errorf("%w: no %s matching tags", ErrNotFound, singular) + } + if len(matched) > 1 { + return zero, fmt.Errorf("%w: multiple %s matching tags", ErrConflict, plural) + } + return matched[0], nil +} + +// ResolveExisting looks up an existing resource by ID first (ignoring errors matched by ignoreLookupErr), +// falling back to tag lookup when the ID is empty or absent. It returns the zero value and nil error when not found. +func ResolveExisting[T any]( + ctx context.Context, + id string, + tags map[string]string, + getByID func(context.Context, string) (T, error), + findByTags func(context.Context, map[string]string) (T, error), + ignoreLookupErr func(error) bool, +) (T, error) { + var zero T + if id != "" { + item, err := getByID(ctx, id) + if err == nil { + return item, nil + } + if !ignoreLookupErr(err) { + return zero, err + } + } + if len(tags) == 0 { + return zero, nil + } + item, err := findByTags(ctx, tags) + if err == nil { + return item, nil + } + if ignoreLookupErr(err) { + return zero, nil + } + return zero, err +} + +// DeleteByIDOrTags deletes a resource by ID when provided, falling back to deleting all resources matching tags +// if the ID is empty or already absent. +func DeleteByIDOrTags( + ctx context.Context, + id string, + tags map[string]string, + deleteByID func(context.Context, string) (bool, error), + listIDsByTags func(context.Context, map[string]string) ([]string, error), +) ([]string, error) { + if id != "" { + deleted, err := deleteByID(ctx, id) + if err != nil { + return nil, err + } + if deleted { + return []string{id}, nil + } + } + if len(tags) == 0 { + return nil, nil + } + ids, err := listIDsByTags(ctx, tags) + if err != nil { + return nil, err + } + var ( + deletedIDs []string + errs []error + ) + for _, targetID := range ids { + if targetID == "" { + continue + } + deleted, err := deleteByID(ctx, targetID) + if err != nil { + errs = append(errs, err) + continue + } + if deleted { + deletedIDs = append(deletedIDs, targetID) + } + } + return deletedIDs, errors.Join(errs...) +} + +func itemContainsTags(item any, tags map[string]string) bool { + switch labeled := item.(type) { + case interface{ GetLabels() map[string]any }: + return MapContains(labeled.GetLabels(), tags) + case interface{ GetLabels() map[string]string }: + return MapContains(labeled.GetLabels(), tags) + default: + return false + } +} + +func MapContains[V any](haystack map[string]V, needle map[string]string) bool { + for k, want := range needle { + got, ok := haystack[k] + if !ok || fmt.Sprint(got) != want { + return false + } + } + return true +} + +func labelSelector(tags map[string]string) string { + parts := make([]string, 0, len(tags)) + for k, v := range tags { + parts = append(parts, k+"="+v) + } + return strings.Join(parts, ",") +} + +func TagsToSDKLabels(tags map[string]string) map[string]any { + out := make(map[string]any, len(tags)) + for k, v := range tags { + out[k] = v + } + return out +} + +func ClassifySDKError(op string, err error) error { + var oapiErr *oapierror.GenericOpenAPIError + if errors.As(err, &oapiErr) { + switch oapiErr.StatusCode { + case http.StatusNotFound: + return fmt.Errorf("%w: %s: %v", ErrNotFound, op, err) + case http.StatusUnauthorized, http.StatusForbidden: + return fmt.Errorf("%w: %s: %v", ErrUnauthorized, op, err) + case http.StatusConflict: + return fmt.Errorf("%w: %s: %v", ErrConflict, op, err) + case http.StatusBadRequest, http.StatusUnprocessableEntity: + return fmt.Errorf("%w: %s: %v", ErrInvalidInput, op, err) + case http.StatusTooManyRequests: + return fmt.Errorf("%w: %s: %v", ErrTransient, op, err) + default: + if oapiErr.StatusCode >= 500 { + return fmt.Errorf("%w: %s: %v", ErrTransient, op, err) + } + } + } + return fmt.Errorf("%w: %s: %v", ErrTransient, op, err) +} diff --git a/cloud/types.go b/cloud/types.go deleted file mode 100644 index 3b5974e..0000000 --- a/cloud/types.go +++ /dev/null @@ -1,141 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -// Package cloud defines the abstraction layer between the controllers and the -// STACKIT SDK. Controllers must not reach into the SDK directly; all calls go -// through the Client interface in this package. -package cloud - -// Server describes a STACKIT compute instance in provider-neutral terms. -type Server struct { - ID string - Name string - State string - PowerStatus string - ProviderID string - AvailabilityZone string - Addresses []Address -} - -// Address is an IP or DNS endpoint of a Server. -type Address struct { - Type string - Address string -} - -// Network is an existing STACKIT virtual network referenced by the provider. -type Network struct { - ID string - Name string - IPv4Prefixes []string -} - -// LoadBalancer describes an API-server load balancer. -type LoadBalancer struct { - ID string - Name string - IP string - DNSName string - Port int32 -} - -// PublicIP describes a STACKIT public IP resource. -type PublicIP struct { - ID string - IP string - NetworkInterfaceID string -} - -// SecurityGroup describes a STACKIT security group. -type SecurityGroup struct { - ID string - Name string -} - -// Bastion describes the provider-managed SSH bastion resources. -type Bastion struct { - ServerID string - ServerState string - ServerPowerStatus string - PublicIPID string - PublicIP string - SecurityGroupID string -} - -type CreateNetworkInput struct { - Name string - IPv4Prefix string - Tags map[string]string -} - -// CreateServerInput holds all parameters required to create a new VM. -type CreateServerInput struct { - Name string - ProjectID string - Region string - ImageID string - MachineType string - AvailabilityZone string - SSHKeyName string - NetworkID string - SecurityGroups []string - UserData []byte - Tags map[string]string - RootVolume RootVolumeInput -} - -// BastionInput holds all parameters required to ensure a bastion host. -type BastionInput struct { - Name string - ProjectID string - Region string - NetworkID string - ImageID string - MachineType string - SSHKeyName string - AllowedCIDRs []string - Tags map[string]string - RootVolume RootVolumeInput - CloudInit []byte -} - -// NodeSSHAccessInput holds parameters required to allow SSH from the bastion -// security group to cluster nodes. -type NodeSSHAccessInput struct { - Name string - ServerID string - BastionSecurityGroupID string - Tags map[string]string -} - -// RootVolumeInput describes the root disk of a VM. -type RootVolumeInput struct { - SizeGiB int - PerformanceClass string - DeleteOnTermination bool -} - -// LoadBalancerInput holds all parameters required to ensure an API-server LB. -type LoadBalancerInput struct { - Name string - ProjectID string - Region string - NetworkID string - Tags map[string]string - Port int32 - Targets []LoadBalancerTargetInput -} - -// LoadBalancerTargetInput describes a VM target in the API-server load -// balancer target pool. -type LoadBalancerTargetInput struct { - Name string - IP string -} diff --git a/config/rbac/role.yaml b/config/rbac/role.yaml index b29226e..75a1891 100644 --- a/config/rbac/role.yaml +++ b/config/rbac/role.yaml @@ -13,6 +13,14 @@ rules: - get - list - watch +- apiGroups: + - "" + - events.k8s.io + resources: + - events + verbs: + - create + - patch - apiGroups: - cluster.x-k8s.io resources: @@ -22,13 +30,6 @@ rules: - get - list - watch -- apiGroups: - - events.k8s.io - resources: - - events - verbs: - - create - - patch - apiGroups: - infrastructure.cluster.x-k8s.io resources: diff --git a/controller/constants.go b/controller/constants.go index cc4e652..3a2b1ce 100644 --- a/controller/constants.go +++ b/controller/constants.go @@ -13,8 +13,6 @@ package controller import "time" const ( - defaultAPIServerPort int32 = 6443 - cloudInitRefKindSecret = "Secret" retryableErrorRequeueAfter = 5 * time.Second diff --git a/controller/controller_test_helpers_test.go b/controller/controller_test_helpers_test.go index b8a77f9..8407de9 100644 --- a/controller/controller_test_helpers_test.go +++ b/controller/controller_test_helpers_test.go @@ -23,6 +23,7 @@ import ( clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" + "github.com/stackitcloud/cluster-api-provider-stackit/scope" ) const ( @@ -118,7 +119,7 @@ func createReadyStackitCluster(ctx context.Context, name, namespace, credentials Expect(k8sClient.Create(ctx, stackitCluster)).To(Succeed()) stackitCluster.Status.Ready = true stackitCluster.Status.APIServerEndpoint = clusterv1.APIEndpoint{Host: "203.0.113.10", Port: 6443} - stackitCluster.Status.FailureDomains = stackitFailureDomains(stackitCluster.Spec.Region) + stackitCluster.Status.FailureDomains = scope.DefaultFailureDomains(stackitCluster.Spec.Region) Expect(k8sClient.Status().Update(ctx, stackitCluster)).To(Succeed()) } diff --git a/controller/server_state_test.go b/controller/server_state_test.go deleted file mode 100644 index 7ed2faa..0000000 --- a/controller/server_state_test.go +++ /dev/null @@ -1,56 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package controller - -import ( - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" -) - -var _ = Describe("serverStateCondition", func() { - DescribeTable("maps server state and power status", - func(state, powerStatus string, wantReady bool, wantReason, wantMessage string, wantWarn bool) { - ready, reason, message, warn := serverStateCondition(state, powerStatus) - Expect(ready).To(Equal(wantReady)) - Expect(reason).To(Equal(wantReason)) - Expect(message).To(Equal(wantMessage)) - Expect(warn).To(Equal(wantWarn)) - }, - Entry("active and running", "ACTIVE", "RUNNING", true, "InstanceActive", "server is active (state ACTIVE, power status RUNNING)", false), - Entry("unknown state", "", "", true, "", "", false), - Entry("active but crashed", "ACTIVE", "CRASHED", false, "InstanceCrashed", - "server crashed (state ACTIVE, power status CRASHED)", true), - Entry("active with power error", "ACTIVE", "ERROR", false, "InstancePowerError", - "server power error (state ACTIVE, power status ERROR)", true), - Entry("creating", "CREATING", "", false, "InstanceStarting", "server is starting (state CREATING)", false), - Entry("rebooting", "REBOOTING", "RUNNING", false, "InstanceBusy", - "server is temporarily unavailable (state REBOOTING, power status RUNNING)", false), - Entry("stopping", "STOPPING", "RUNNING", false, "InstanceStopping", - "server is stopping (state STOPPING, power status RUNNING)", false), - Entry("stopped", "INACTIVE", "STOPPED", false, "InstanceStopped", - "server is stopped (state INACTIVE, power status STOPPED)", true), - Entry("deallocating", "DEALLOCATING", "STOPPED", false, "InstanceDeallocating", - "server is being deallocated (state DEALLOCATING, power status STOPPED)", false), - Entry("deallocated", "DEALLOCATED", "STOPPED", false, "InstanceDeallocated", - "server is deallocated (state DEALLOCATED, power status STOPPED)", true), - Entry("paused", "PAUSED", "", false, "InstancePaused", "server is paused (state PAUSED)", true), - Entry("entering rescue", "RESCUING", "", false, "InstanceEnteringRescue", - "server is entering rescue mode (state RESCUING)", false), - Entry("leaving rescue", "UNRESCUING", "", false, "InstanceLeavingRescue", - "server is leaving rescue mode (state UNRESCUING)", false), - Entry("rescue", "RESCUE", "RUNNING", false, "InstanceInRescue", - "server is in rescue mode (state RESCUE, power status RUNNING)", true), - Entry("deleting", "DELETING", "", false, "InstanceDeleting", "server is being deleted (state DELETING)", false), - Entry("error", "ERROR", "ERROR", false, "InstanceFailed", "server failed (state ERROR, power status ERROR)", true), - Entry("undocumented state", "SOMETHING", "", false, "InstanceNotActive", - "server is not active (state SOMETHING)", false), - ) -}) diff --git a/controller/stackitcluster_bastion.go b/controller/stackitcluster_bastion.go index 4ec855a..42de08a 100644 --- a/controller/stackitcluster_bastion.go +++ b/controller/stackitcluster_bastion.go @@ -14,7 +14,6 @@ import ( "context" "crypto/sha256" "fmt" - "net/netip" "time" corev1 "k8s.io/api/core/v1" @@ -27,8 +26,9 @@ import ( logf "sigs.k8s.io/controller-runtime/pkg/log" infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" - bastionservice "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/bastion" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/publicip" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" "github.com/stackitcloud/cluster-api-provider-stackit/scope" ) @@ -38,18 +38,10 @@ const bastionDisabledReason = "Skipped" func (r *StackitClusterReconciler) reconcileBastion( ctx context.Context, - cloudClient cloud.Client, clusterScope *scope.ClusterScope, ) (ctrl.Result, bool, error) { log := logf.FromContext(ctx) stackitCluster := clusterScope.StackitCluster - input := bastionservice.Input(clusterScope, nil) - status := cloud.Bastion{ - ServerID: stackitCluster.Status.Bastion.ServerID, - PublicIPID: stackitCluster.Status.Bastion.PublicIPID, - PublicIP: stackitCluster.Status.Bastion.PublicIP, - SecurityGroupID: stackitCluster.Status.Bastion.SecurityGroupID, - } if !stackitCluster.Spec.Bastion.Enabled { // The reason is set only after a cleanup has succeeded, so anything else @@ -57,14 +49,9 @@ func (r *StackitClusterReconciler) reconcileBastion( // the status keeps the tag-based cleanup to once per cluster. condition := meta.FindStatusCondition(stackitCluster.Status.Conditions, infrav1.ClusterBastionReadyCondition) if condition == nil || condition.Reason != bastionDisabledReason { - if err := cloudClient.DeleteNodeSSHAccess(ctx, bastionservice.NodeSSHAccessTags(stackitCluster)); err != nil { - return ctrl.Result{}, false, err - } - if err := cloudClient.DeleteBastion(ctx, input, status); err != nil { + if err := deleteBastion(ctx, clusterScope); err != nil { return ctrl.Result{}, false, err } - clusterScope.ClearBastionStatus() - record.Event(stackitCluster, "BastionDeleted", "Deleted bastion") } clusterScope.SetConditions( metav1.ConditionTrue, @@ -75,18 +62,6 @@ func (r *StackitClusterReconciler) reconcileBastion( return ctrl.Result{}, true, nil } - if err := validateBastionSpec(stackitCluster.Spec.Bastion); err != nil { - log.Error(err, "Invalid bastion spec", "cluster", stackitCluster.Name) - record.Warnf(stackitCluster, "InvalidBastionSpec", "Invalid bastion spec: %v", err) - clusterScope.SetNotReady( - "InvalidBastionSpec", - err.Error(), - infrav1.ClusterBastionReadyCondition, - infrav1.ClusterReadyCondition, - ) - return ctrl.Result{}, false, nil - } - cloudInit, err := r.resolveBastionCloudInit(ctx, stackitCluster) if err != nil { log.Error(err, "Failed to resolve bastion cloud-init", "cluster", stackitCluster.Name) @@ -99,16 +74,12 @@ func (r *StackitClusterReconciler) reconcileBastion( ) return ctrl.Result{}, false, nil } - input.CloudInit = cloudInit + clusterScope.SetBastionCloudInit(cloudInit, bastionCloudInitHash(cloudInit)) if bastionNeedsRecreate(stackitCluster, cloudInit) { - if err := cloudClient.DeleteNodeSSHAccess(ctx, bastionservice.NodeSSHAccessTags(stackitCluster)); err != nil && !cloud.IsNotFound(err) { - return ctrl.Result{}, false, err - } - if err := cloudClient.DeleteBastion(ctx, input, status); err != nil && !cloud.IsNotFound(err) { + if err := server.New(clusterScope).Delete(ctx); err != nil { return ctrl.Result{}, false, err } - clusterScope.ClearBastionStatus() clusterScope.SetNotReady( "Recreating", "recreating bastion because cloudInitRef content changed", @@ -122,18 +93,22 @@ func (r *StackitClusterReconciler) reconcileBastion( return ctrl.Result{RequeueAfter: retryableErrorRequeueAfter}, false, nil } - hadBastionStatus := hasBastionStatus(stackitCluster.Status.Bastion) - bastion, err := cloudClient.EnsureBastion(ctx, input) - if err != nil { + if err := server.New(clusterScope).Reconcile(ctx); err != nil { return ctrl.Result{}, false, err } - clusterScope.SetBastionStatus(bastion, bastionCloudInitHash(cloudInit)) - if !hadBastionStatus { + if clusterScope.BastionServerCreated() { record.Eventf( - stackitCluster, "BastionCreated", "Created bastion %s", bastion.ServerID, + stackitCluster, "BastionCreated", "Created bastion %s", stackitCluster.Status.Bastion.ServerID, ) } - if ready, reason, message, warn := serverStateCondition(bastion.ServerState, bastion.ServerPowerStatus); !ready { + if err := securitygroup.New(clusterScope).Reconcile(ctx); err != nil { + return ctrl.Result{}, false, err + } + if err := publicip.New(clusterScope).Reconcile(ctx); err != nil { + return ctrl.Result{}, false, err + } + state, powerStatus := clusterScope.BastionServerState() + if ready, reason, message, warn := server.StateCondition(state, powerStatus); !ready { previousReason := "" if previous := meta.FindStatusCondition(stackitCluster.Status.Conditions, infrav1.ClusterBastionReadyCondition); previous != nil { previousReason = previous.Reason @@ -141,11 +116,11 @@ func (r *StackitClusterReconciler) reconcileBastion( clusterScope.SetNotReady(reason, "bastion "+message, infrav1.ClusterBastionReadyCondition, infrav1.ClusterReadyCondition) // Only warn on entering the state, not on every requeue. if warn && previousReason != reason { - record.Warnf(stackitCluster, reason, "Bastion server %s: %s", bastion.ServerID, message) + record.Warnf(stackitCluster, reason, "Bastion server %s: %s", stackitCluster.Status.Bastion.ServerID, message) } return ctrl.Result{RequeueAfter: 15 * time.Second}, false, nil } - if bastion.PublicIP == "" { + if stackitCluster.Status.Bastion.PublicIP == "" { clusterScope.SetNotReady( "Provisioning", "waiting for bastion public IP address", @@ -163,33 +138,28 @@ func (r *StackitClusterReconciler) reconcileBastion( return ctrl.Result{}, true, nil } -func validateBastionSpec(spec infrav1.StackitBastionSpec) error { - if spec.ImageID == "" { - return fmt.Errorf("%w: bastion.imageID is required", cloud.ErrInvalidInput) - } - if spec.MachineType == "" { - return fmt.Errorf("%w: bastion.machineType is required", cloud.ErrInvalidInput) +func deleteBastion( + ctx context.Context, + clusterScope *scope.ClusterScope, +) error { + hadBastion := clusterScope.HasBastionStatus() + if err := publicip.New(clusterScope).Delete(ctx); err != nil { + return err } - if spec.SSHKeyName == "" { - return fmt.Errorf("%w: bastion.sshKeyName is required", cloud.ErrInvalidInput) + if err := server.New(clusterScope).Delete(ctx); err != nil { + return err } - if len(spec.AllowedCIDRs) == 0 { - return fmt.Errorf("%w: bastion.allowedCIDRs is required", cloud.ErrInvalidInput) + if hadBastion { + record.Event(clusterScope.StackitCluster, "BastionDeleted", "Deleted bastion") } - for _, cidr := range spec.AllowedCIDRs { - if _, err := netip.ParsePrefix(cidr); err != nil { - return fmt.Errorf("%w: bastion.allowedCIDRs contains invalid CIDR %q", cloud.ErrInvalidInput, cidr) - } + if err := securitygroup.New(clusterScope).Delete(ctx); err != nil { + return err } return nil } -func hasBastionStatus(status infrav1.StackitBastionStatus) bool { - return status.ServerID != "" || status.PublicIPID != "" || status.PublicIP != "" || status.SecurityGroupID != "" -} - func bastionNeedsRecreate(stackitCluster *infrav1.StackitCluster, cloudInit []byte) bool { - if !hasBastionStatus(stackitCluster.Status.Bastion) { + if stackitCluster.Status.Bastion.ServerID == "" { return false } return stackitCluster.Status.Bastion.CloudInitHash != bastionCloudInitHash(cloudInit) diff --git a/controller/stackitcluster_controller.go b/controller/stackitcluster_controller.go index a9e4a3c..5db54df 100644 --- a/controller/stackitcluster_controller.go +++ b/controller/stackitcluster_controller.go @@ -22,16 +22,22 @@ import ( "fmt" "maps" "slices" + "time" corev1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" clusterutil "sigs.k8s.io/cluster-api/util" + "sigs.k8s.io/cluster-api/util/collections" + "sigs.k8s.io/cluster-api/util/record" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/builder" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/handler" logf "sigs.k8s.io/controller-runtime/pkg/log" @@ -40,6 +46,10 @@ import ( infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" "github.com/stackitcloud/cluster-api-provider-stackit/cloud" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/availabilityzone" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" "github.com/stackitcloud/cluster-api-provider-stackit/scope" "github.com/stackitcloud/cluster-api-provider-stackit/util" ) @@ -54,6 +64,22 @@ type StackitClusterReconciler struct { CloudClientFactory cloud.Factory } +// SetupWithManager registers the controller with the manager. +func (r *StackitClusterReconciler) SetupWithManager(mgr ctrl.Manager) error { + return ctrl.NewControllerManagedBy(mgr). + For(&infrav1.StackitCluster{}). + Watches(&clusterv1.Cluster{}, handler.EnqueueRequestsFromMapFunc(r.filterForStackitClusterResources)). + Watches( + &clusterv1.Machine{}, + handler.EnqueueRequestsFromMapFunc(r.loadBalancerTargetsForControlPlanes), + builder.WithPredicates(predicate.Funcs{UpdateFunc: machineTargetPoolChanged}), + ). + Watches(&corev1.ConfigMap{}, handler.EnqueueRequestsFromMapFunc(r.stackitClusterRequestsForCloudInitRef)). + Watches(&corev1.Secret{}, handler.EnqueueRequestsFromMapFunc(r.stackitClusterRequestsForCloudInitRef)). + Named("stackitcluster"). + Complete(r) +} + // +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=stackitclusters,verbs=get;list;watch;create;update;patch;delete // +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=stackitclusters/status,verbs=get;update;patch // +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=stackitclusters/finalizers,verbs=update @@ -62,6 +88,7 @@ type StackitClusterReconciler struct { // +kubebuilder:rbac:groups="",resources=secrets,verbs=get;list;watch // +kubebuilder:rbac:groups="",resources=configmaps,verbs=get;list;watch // +kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch +// +kubebuilder:rbac:groups="",resources=events,verbs=create;patch func (r *StackitClusterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, err error) { log := logf.FromContext(ctx) @@ -94,10 +121,10 @@ func (r *StackitClusterReconciler) Reconcile(ctx context.Context, req ctrl.Reque }() if paused, message := util.ReconciliationPaused(cluster, stackitCluster); paused { - util.SetPausedCondition(&stackitCluster.Status.Conditions, stackitCluster.Generation, true, message) + clusterScope.SetPausedCondition(true, message) return ctrl.Result{}, nil } - util.SetPausedCondition(&stackitCluster.Status.Conditions, stackitCluster.Generation, false, "") + clusterScope.SetPausedCondition(false, "") if !stackitCluster.DeletionTimestamp.IsZero() { return r.reconcileDelete(ctx, clusterScope) @@ -187,18 +214,339 @@ func (r *StackitClusterReconciler) stackitClusterRequestsForCloudInitRef(ctx con return requests } -// SetupWithManager registers the controller with the manager. -func (r *StackitClusterReconciler) SetupWithManager(mgr ctrl.Manager) error { - return ctrl.NewControllerManagedBy(mgr). - For(&infrav1.StackitCluster{}). - Watches(&clusterv1.Cluster{}, handler.EnqueueRequestsFromMapFunc(r.filterForStackitClusterResources)). - Watches( - &clusterv1.Machine{}, - handler.EnqueueRequestsFromMapFunc(r.loadBalancerTargetsForControlPlanes), - builder.WithPredicates(predicate.Funcs{UpdateFunc: machineTargetPoolChanged}), - ). - Watches(&corev1.ConfigMap{}, handler.EnqueueRequestsFromMapFunc(r.stackitClusterRequestsForCloudInitRef)). - Watches(&corev1.Secret{}, handler.EnqueueRequestsFromMapFunc(r.stackitClusterRequestsForCloudInitRef)). - Named("stackitcluster"). - Complete(r) +func (r *StackitClusterReconciler) reconcileNormal(ctx context.Context, clusterScope *scope.ClusterScope) (ctrl.Result, error) { + log := logf.FromContext(ctx) + stackitCluster := clusterScope.StackitCluster + + if !controllerutil.ContainsFinalizer(stackitCluster, infrav1.ClusterFinalizer) { + controllerutil.AddFinalizer(stackitCluster, infrav1.ClusterFinalizer) + // Persisted immediately, before any cloud resource can be created, to + // ensure nothing is running behind an object that carries no finalizer to + // clean it up. + if err := clusterScope.PatchObject(ctx); err != nil { + return ctrl.Result{}, fmt.Errorf("persist finalizer: %w", err) + } + } + clusterScope.SetFailureDomains(scope.DefaultFailureDomains(stackitCluster.Spec.Region)) + + cloudClient, err := util.BuildCloudClient(ctx, r.Client, r.CloudClientFactory, stackitCluster) + if err != nil { + log.Error(err, "Failed to build cloud client for cluster", "cluster", stackitCluster.Name) + record.Warnf(stackitCluster, "InvalidCredentials", "Failed to build cloud client: %v", err) + return clusterScope.CredentialFailureResult( + err, + credentialsRetryRequeueAfter, + infrav1.ClusterCredentialsReadyCondition, + infrav1.ClusterReadyCondition, + ) + } + clusterScope.SetCloudClient(cloudClient) + clusterScope.SetConditions( + metav1.ConditionTrue, + "Available", + "", + infrav1.ClusterCredentialsReadyCondition, + ) + + if err := availabilityzone.New(clusterScope).Reconcile(ctx); err != nil { + return clusterScope.CloudFailureResult( + "AvailabilityZonesError", + err, + retryableErrorRequeueAfter, + true, + infrav1.ClusterReadyCondition, + ) + } + + if err := network.New(clusterScope).Reconcile(ctx); err != nil { + if stackitCluster.Spec.Network.ID != "" { + log.Error(err, "Failed to get network", + "networkID", stackitCluster.Spec.Network.ID, + "region", stackitCluster.Spec.Region, + ) + record.Warnf( + stackitCluster, "FailedGetNetwork", + "Failed to get network %s in region %s: %v", + stackitCluster.Spec.Network.ID, stackitCluster.Spec.Region, err, + ) + return clusterScope.CloudFailureResult( + "NetworkNotFound", + err, + retryableErrorRequeueAfter, + false, + infrav1.ClusterNetworkReadyCondition, + infrav1.ClusterReadyCondition, + ) + } + log.Error(err, "Failed to reconcile managed network", + "cluster", stackitCluster.Name, + "region", stackitCluster.Spec.Region, + ) + record.Warnf( + stackitCluster, "FailedCreateNetwork", + "Failed to reconcile managed network in region %s: %v", + stackitCluster.Spec.Region, err, + ) + return clusterScope.CloudFailureResult( + "NetworkCreateError", + err, + retryableErrorRequeueAfter, + false, + infrav1.ClusterNetworkReadyCondition, + infrav1.ClusterReadyCondition, + ) + } + if clusterScope.NetworkCreated() { + record.Eventf(stackitCluster, "NetworkCreated", "Created managed network %s", stackitCluster.Status.Network.ID) + } + clusterScope.SetConditions( + metav1.ConditionTrue, + "Available", + "", + infrav1.ClusterNetworkReadyCondition, + ) + + if stackitCluster.Spec.APIServerLoadBalancer.Enabled { + // STACKIT takes an explicit target list rather than label-based + // membership, so exactly one reconciler owns the pool. Machines being + // deleted drop out here, before the node is drained. + machines, err := collections.GetFilteredMachinesForCluster( + ctx, + r.Client, + clusterScope.Cluster, + collections.ControlPlaneMachines(clusterScope.Cluster.Name), + collections.ActiveMachines, + ) + if err != nil { + clusterScope.SetConditions( + metav1.ConditionFalse, + "MachineListError", + err.Error(), + infrav1.ClusterLoadBalancerReadyCondition, + ) + return ctrl.Result{}, fmt.Errorf("list control plane machines: %w", err) + } + targets := loadbalancer.APIServerTargets(machines.UnsortedList()) + + // Seeding with the real targets lets a load balancer deleted out of band + // come back with the control plane behind it. + seed := targets + if len(seed) == 0 { + seed = []loadbalancer.Target{loadbalancer.BootstrapTarget(clusterScope.BootstrapTargetIP())} + } + clusterScope.SetAPIServerLoadBalancerTargets(targets, seed) + + previousEndpointHost := stackitCluster.Status.APIServerEndpoint.Host + wasLBReady := meta.IsStatusConditionTrue(stackitCluster.Status.Conditions, infrav1.ClusterLoadBalancerReadyCondition) + + err = loadbalancer.New(clusterScope).Reconcile(ctx) + if clusterScope.APIServerLoadBalancerCreated() { + record.Eventf( + stackitCluster, "LoadBalancerCreated", + "Created API server load balancer %s", stackitCluster.Status.APIServerLoadBalancerID, + ) + } + if loadbalancer.IsTargetPoolUpdateError(err) { + if !shared.IsRetryable(err) { + record.Warnf( + stackitCluster, "LoadBalancerTargetError", + "Cannot update API server load balancer target pool: %v", err, + ) + } + // Scoped to the load balancer condition: failing the cluster would + // stop the machine reconciler from replacing the broken machine. + clusterScope.SetConditions( + metav1.ConditionFalse, + "LoadBalancerTargetError", + err.Error(), + infrav1.ClusterLoadBalancerReadyCondition, + ) + // Requeue even on a permanent error: this return skips SetReady, so + // no machine exists yet whose events could retry it. + return ctrl.Result{RequeueAfter: retryableErrorRequeueAfter}, nil + } + if err != nil { + log.Error(err, "Failed to create API server load balancer", + "cluster", stackitCluster.Name, + "region", stackitCluster.Spec.Region, + ) + record.Warnf( + stackitCluster, "FailedCreateLoadBalancer", + "Failed to create API server load balancer: %v", err, + ) + return clusterScope.CloudFailureResult( + "LoadBalancerError", + err, + retryableErrorRequeueAfter, + false, + infrav1.ClusterLoadBalancerReadyCondition, + infrav1.ClusterReadyCondition, + ) + } + if stackitCluster.Status.APIServerEndpoint.Host == "" { + clusterScope.SetNotReady( + "Provisioning", + "waiting for API server load balancer IP address", + infrav1.ClusterLoadBalancerReadyCondition, + infrav1.ClusterReadyCondition, + ) + return ctrl.Result{RequeueAfter: 10 * time.Second}, nil + } + + isLBReady := wasLBReady && previousEndpointHost == stackitCluster.Status.APIServerEndpoint.Host + if !isLBReady { + clusterScope.SetConditions( + metav1.ConditionTrue, + "Available", + "", + infrav1.ClusterLoadBalancerReadyCondition, + ) + record.Eventf( + stackitCluster, "LoadBalancerReady", + "API server load balancer is ready at %s", stackitCluster.Status.APIServerEndpoint.Host, + ) + } + } else if stackitCluster.Spec.ControlPlaneEndpoint.Host != "" { + stackitCluster.Status.APIServerEndpoint = stackitCluster.Spec.ControlPlaneEndpoint + clusterScope.SetConditions( + metav1.ConditionTrue, + "Skipped", + "external endpoint provided", + infrav1.ClusterLoadBalancerReadyCondition, + ) + } else { + log.Error(errors.New("controlPlaneEndpoint host is empty"), "API server load balancer is disabled and controlPlaneEndpoint is empty", "cluster", stackitCluster.Name) + record.Warn(stackitCluster, "EndpointMissing", "apiServerLoadBalancer.enabled is false and controlPlaneEndpoint is empty") + clusterScope.SetNotReady( + "EndpointMissing", + "apiServerLoadBalancer.enabled is false and controlPlaneEndpoint is empty", + infrav1.ClusterLoadBalancerReadyCondition, + infrav1.ClusterReadyCondition, + ) + return ctrl.Result{}, nil + } + + if result, ready, err := r.reconcileBastion(ctx, clusterScope); err != nil { + log.Error(err, "Failed to reconcile bastion", + "cluster", stackitCluster.Name, + ) + record.Warnf( + stackitCluster, "FailedCreateBastion", + "Failed to reconcile bastion: %v", err, + ) + return clusterScope.CloudFailureResult( + "BastionError", + err, + retryableErrorRequeueAfter, + false, + infrav1.ClusterBastionReadyCondition, + infrav1.ClusterReadyCondition, + ) + } else if !ready { + return result, nil + } + + clusterScope.SetReady() + log.V(1).Info("Reconciled StackitCluster", "endpoint", stackitCluster.Status.APIServerEndpoint) + return ctrl.Result{}, nil +} + +func (r *StackitClusterReconciler) reconcileDelete(ctx context.Context, clusterScope *scope.ClusterScope) (ctrl.Result, error) { + log := logf.FromContext(ctx) + stackitCluster := clusterScope.StackitCluster + + // Machines resolve their credentials and project context through this + // StackitCluster, so the finalizer has to stay while any of them remain. + machines, err := collections.GetFilteredMachinesForCluster(ctx, r.Client, clusterScope.Cluster) + if err != nil { + log.Error(err, "Failed to list Machines for cluster during deletion", "cluster", clusterScope.Cluster.Name) + record.Warnf(stackitCluster, "FailedListMachines", + "Failed to list Machines for cluster %s: %v", clusterScope.Cluster.Name, err) + return ctrl.Result{}, fmt.Errorf("list Machines for cluster %s: %w", clusterScope.Cluster.Name, err) + } + if machines.Len() > 0 { + log.Info( + "Waiting for Machines to be deleted before removing the StackitCluster finalizer", + "remainingMachines", machines.Len(), + ) + return ctrl.Result{RequeueAfter: deleteRequeueAfter}, nil + } + + // Cleanup runs unconditionally: neither spec nor status is a trustworthy + // record of what exists in the cloud. The load balancer, public IP, + // security group, server, and network services fall back to tag lookups and + // tolerate NotFound. + cloudClient, err := util.BuildCloudClient(ctx, r.Client, r.CloudClientFactory, stackitCluster) + if err != nil { + // A missing credentials Secret cannot be recovered from and commonly + // disappears first during namespace teardown, so finalize and make the + // possible leak loud rather than stranding the cluster in Terminating. + // Every other credentials problem is fixable and keeps retrying. + if apierrors.IsNotFound(err) { + log.Error(err, "Credentials secret is gone; finalizing without cloud cleanup", "cluster", stackitCluster.Name) + record.Warnf(stackitCluster, "CleanupSkipped", + "Credentials Secret is gone; finalizing without cloud cleanup. "+ + "Any remaining STACKIT resources for this cluster must be removed manually: %v", err) + controllerutil.RemoveFinalizer(stackitCluster, infrav1.ClusterFinalizer) + return ctrl.Result{}, nil + } + log.Error(err, "Failed to build cloud client for cluster deletion", "cluster", stackitCluster.Name) + record.Warnf(stackitCluster, "InvalidCredentials", + "Failed to build cloud client for deletion: %v", err) + return clusterScope.CredentialFailureResult( + err, + credentialsRetryRequeueAfter, + infrav1.ClusterCredentialsReadyCondition, + ) + } + clusterScope.SetCloudClient(cloudClient) + loadBalancerID := stackitCluster.Status.APIServerLoadBalancerID + if err := loadbalancer.New(clusterScope).Delete(ctx); err != nil { + log.Error(err, "Failed to delete API server load balancer", "cluster", stackitCluster.Name, "loadBalancerID", loadBalancerID) + record.Warnf(stackitCluster, "FailedDeleteLoadBalancer", + "Failed to delete API server load balancer %s: %v", loadBalancerID, err) + return ctrl.Result{}, err + } + if loadBalancerID != "" { + record.Eventf( + stackitCluster, "LoadBalancerDeleted", + "Deleted API server load balancer %s", loadBalancerID, + ) + } + if err := deleteBastion(ctx, clusterScope); err != nil { + log.Error(err, "Failed to delete bastion", "cluster", stackitCluster.Name) + record.Warnf(stackitCluster, "FailedDeleteBastion", + "Failed to delete bastion: %v", err) + return ctrl.Result{}, err + } + networkID := stackitCluster.Status.Network.ID + if err := network.New(clusterScope).Delete(ctx); err != nil { + if shared.IsConflict(err) { + log.Info("Managed network still has resources attached; requeueing deletion", + "cluster", stackitCluster.Name, + "networkID", networkID, + ) + clusterScope.SetConditions( + metav1.ConditionFalse, + "NetworkInUse", + err.Error(), + infrav1.ClusterNetworkReadyCondition, + ) + record.Warnf(stackitCluster, "NetworkInUse", + "Managed network %s still has active resources attached; retrying deletion: %v", networkID, err) + return ctrl.Result{RequeueAfter: deleteRequeueAfter}, nil + } + log.Error(err, "Failed to delete managed network", + "cluster", stackitCluster.Name, + "networkID", networkID, + ) + record.Warnf(stackitCluster, "FailedDeleteNetwork", + "Failed to delete managed network %s: %v", networkID, err) + return ctrl.Result{}, err + } + if networkID != "" && stackitCluster.Spec.Network.ID == "" { + record.Eventf(stackitCluster, "NetworkDeleted", "Deleted managed network %s", networkID) + } + controllerutil.RemoveFinalizer(stackitCluster, infrav1.ClusterFinalizer) + return ctrl.Result{}, nil } diff --git a/controller/stackitcluster_controller_test.go b/controller/stackitcluster_controller_test.go index a92ee67..26a533c 100644 --- a/controller/stackitcluster_controller_test.go +++ b/controller/stackitcluster_controller_test.go @@ -28,7 +28,11 @@ import ( infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" "github.com/stackitcloud/cluster-api-provider-stackit/cloud" cloudfake "github.com/stackitcloud/cluster-api-provider-stackit/cloud/fake" - bastionservice "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/bastion" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" + "github.com/stackitcloud/cluster-api-provider-stackit/scope" ) var _ = Describe("StackitCluster Controller", func() { @@ -51,7 +55,7 @@ var _ = Describe("StackitCluster Controller", func() { credentials = "stackit-credentials-" + clusterName stackitKey = types.NamespacedName{Namespace: namespace, Name: clusterName} request = reconcile.Request{NamespacedName: stackitKey} - fakeCloud = cloudfake.New(cloud.Network{ID: testNetworkID, Name: "network"}) + fakeCloud = cloudfake.New(network.Network{ID: testNetworkID, Name: "network"}) reconciler = &StackitClusterReconciler{ Client: k8sClient, Scheme: k8sClient.Scheme(), @@ -132,7 +136,7 @@ var _ = Describe("StackitCluster Controller", func() { Expect(err).NotTo(HaveOccurred()) _, err = fakeCloud.GetNetwork(ctx, got.Status.Network.ID) - Expect(cloud.IsNotFound(err)).To(BeTrue(), "managed network should be deleted on cluster teardown") + Expect(shared.IsNotFound(err)).To(BeTrue(), "managed network should be deleted on cluster teardown") }) It("resolves and deletes managed network via tags even when status.network was lost", func() { @@ -167,7 +171,7 @@ var _ = Describe("StackitCluster Controller", func() { Expect(err).NotTo(HaveOccurred()) _, err = fakeCloud.GetNetwork(ctx, createdNetID) - Expect(cloud.IsNotFound(err)).To(BeTrue(), "network should be deleted via tag fallback") + Expect(shared.IsNotFound(err)).To(BeTrue(), "network should be deleted via tag fallback") }) It("requeues deletion with condition when managed network has attached resources", func() { @@ -191,7 +195,7 @@ var _ = Describe("StackitCluster Controller", func() { Expect(k8sClient.Get(ctx, key, got)).To(Succeed()) By("injecting a conflict error on network delete") - fakeCloud.FailNextDeleteNetwork = fmt.Errorf("ports still attached: %w", cloud.ErrConflict) + fakeCloud.FailNextDeleteNetwork = fmt.Errorf("ports still attached: %w", shared.ErrConflict) Expect(k8sClient.Delete(ctx, got)).To(Succeed()) result, err := reconciler.Reconcile(ctx, req) @@ -238,7 +242,33 @@ var _ = Describe("StackitCluster Controller", func() { Expect(got.Status.Bastion.SecurityGroupID).NotTo(BeEmpty()) Expect(fakeCloud.ServerCount()).To(Equal(1)) Expect(fakeCloud.PublicIPCount()).To(Equal(1)) - Expect(fakeCloud.SecurityGroupCount()).To(Equal(1)) + Expect(fakeCloud.SecurityGroupCount()).To(Equal(2)) + Expect(fakeCloud.SecurityGroupRules(got.Status.Bastion.SecurityGroupID)).To(ConsistOf( + securitygroup.Rule{ + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 22, + PortMax: 22, + IPRange: "203.0.113.10/32", + }, + securitygroup.Rule{ + Direction: securitygroup.DirectionEgress, + }, + )) + nodeSG := fakeCloud.FindSecurityGroupByTags(scope.NodeSSHTags(got)) + Expect(nodeSG).NotTo(BeNil()) + Expect(fakeCloud.SecurityGroupRules(nodeSG.ID)).To(ConsistOf( + securitygroup.Rule{ + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 22, + PortMax: 22, + RemoteSecurityGroupID: got.Status.Bastion.SecurityGroupID, + }, + securitygroup.Rule{ + Direction: securitygroup.DirectionEgress, + }, + )) expectCondition(got.Status.Conditions, infrav1.ClusterBastionReadyCondition, metav1.ConditionTrue, "Available") }) @@ -272,14 +302,24 @@ var _ = Describe("StackitCluster Controller", func() { Expect(err).NotTo(HaveOccurred()) Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) - _, err = fakeCloud.EnsureNodeSSHAccess(ctx, cloud.NodeSSHAccessInput{ - Name: got.Name + "-node-ssh", - ServerID: got.Status.Bastion.ServerID, - BastionSecurityGroupID: got.Status.Bastion.SecurityGroupID, - Tags: bastionservice.NodeSSHAccessTags(got), - }) - Expect(err).NotTo(HaveOccurred()) Expect(fakeCloud.SecurityGroupCount()).To(Equal(2)) + nodeSG := fakeCloud.FindSecurityGroupByTags(scope.NodeSSHTags(got)) + Expect(nodeSG).NotTo(BeNil()) + stackitMachine := newStackitMachine(got.Name+"-worker-0", got.Namespace, "worker-0") + stackitMachine.Spec.SecurityGroups = []string{nodeSG.ID} + machineScope, err := scope.NewMachineScope( + k8sClient, + &clusterv1.Cluster{ObjectMeta: metav1.ObjectMeta{Name: got.Name, Namespace: got.Namespace}}, + &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "worker-0", UID: "uid-1"}}, + got, + stackitMachine, + ) + Expect(err).NotTo(HaveOccurred()) + machineScope.SetCloudClient(fakeCloud) + Expect(server.New(machineScope).Reconcile(ctx)).To(Succeed()) + workerServerID := stackitMachine.Status.InstanceID + Expect(fakeCloud.ServerHasSecurityGroup(workerServerID, nodeSG.ID)).To(BeTrue()) + got.Spec.Bastion.Enabled = false Expect(k8sClient.Update(ctx, got)).To(Succeed()) @@ -289,7 +329,8 @@ var _ = Describe("StackitCluster Controller", func() { Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) Expect(got.Status.Bastion).To(Equal(infrav1.StackitBastionStatus{})) - Expect(fakeCloud.ServerCount()).To(Equal(0)) + Expect(fakeCloud.ServerHasSecurityGroup(workerServerID, nodeSG.ID)).To(BeFalse()) + Expect(fakeCloud.ServerCount()).To(Equal(1)) Expect(fakeCloud.PublicIPCount()).To(Equal(0)) Expect(fakeCloud.SecurityGroupCount()).To(Equal(0)) expectCondition(got.Status.Conditions, infrav1.ClusterBastionReadyCondition, metav1.ConditionTrue, "Skipped") @@ -305,13 +346,6 @@ var _ = Describe("StackitCluster Controller", func() { Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) Expect(got.Status.Bastion.PublicIP).NotTo(BeEmpty()) - _, err = fakeCloud.EnsureNodeSSHAccess(ctx, cloud.NodeSSHAccessInput{ - Name: got.Name + "-node-ssh", - ServerID: got.Status.Bastion.ServerID, - BastionSecurityGroupID: got.Status.Bastion.SecurityGroupID, - Tags: bastionservice.NodeSSHAccessTags(got), - }) - Expect(err).NotTo(HaveOccurred()) Expect(fakeCloud.SecurityGroupCount()).To(Equal(2)) Expect(k8sClient.Delete(ctx, got)).To(Succeed()) @@ -354,7 +388,7 @@ var _ = Describe("StackitCluster Controller", func() { got.Status.Bastion = infrav1.StackitBastionStatus{} Expect(k8sClient.Status().Update(ctx, got)).To(Succeed()) Expect(k8sClient.Get(ctx, key, got)).To(Succeed()) - Expect(hasBastionStatus(got.Status.Bastion)).To(BeFalse()) + Expect(got.Status.Bastion).To(Equal(infrav1.StackitBastionStatus{})) Expect(got.Status.APIServerLoadBalancerID).To(BeEmpty()) By("deleting the cluster") @@ -403,6 +437,41 @@ var _ = Describe("StackitCluster Controller", func() { }).Should(BeTrue(), "cluster stayed in Terminating because the finalizer was never removed") }) + It("requeues on invalid credentials during deletion and keeps the finalizer until corrected", func() { + _, err := reconciler.Reconcile(ctx, request) + Expect(err).NotTo(HaveOccurred()) + Expect(fakeCloud.LoadBalancerCount()).To(Equal(1)) + + got := &infrav1.StackitCluster{} + Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) + Expect(k8sClient.Delete(ctx, got)).To(Succeed()) + + reconciler.CloudClientFactory = func(context.Context, cloud.Credentials) (cloud.Client, error) { + return nil, fmt.Errorf("authenticate: %w", shared.ErrUnauthorized) + } + + result, err := reconciler.Reconcile(ctx, request) + Expect(err).NotTo(HaveOccurred()) + Expect(result.RequeueAfter).To(Equal(credentialsRetryRequeueAfter)) + + Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) + Expect(got.Status.Ready).To(BeFalse()) + Expect(got.Finalizers).To(ContainElement(infrav1.ClusterFinalizer)) + expectCondition(got.Status.Conditions, infrav1.ClusterCredentialsReadyCondition, metav1.ConditionFalse, "CredentialsInvalid") + + By("correcting the credentials so deletion succeeds") + reconciler.CloudClientFactory = func(context.Context, cloud.Credentials) (cloud.Client, error) { + return fakeCloud, nil + } + + _, err = reconciler.Reconcile(ctx, request) + Expect(err).NotTo(HaveOccurred()) + Expect(fakeCloud.LoadBalancerCount()).To(Equal(0)) + Eventually(func() bool { + return apierrors.IsNotFound(k8sClient.Get(ctx, stackitKey, &infrav1.StackitCluster{})) + }).Should(BeTrue()) + }) + It("tears the bastion down when disabled even if its status was never persisted", func() { // With the status lost, a status-gated teardown would report the bastion // as disabled while leaving port 22 open. @@ -488,14 +557,6 @@ var _ = Describe("StackitCluster Controller", func() { "load balancer leaked because cleanup was gated on spec and status") }) - It("validates bastion specs", func() { - spec := validBastionSpec() - Expect(validateBastionSpec(spec)).To(Succeed()) - - spec.AllowedCIDRs = []string{"not-a-cidr"} - Expect(validateBastionSpec(spec)).To(MatchError(ContainSubstring("invalid CIDR"))) - }) - It("creates the bastion with cloud-init user data from a ConfigMap", func() { expectBastionCloudInit( ctx, reconciler, request, stackitKey, fakeCloud, @@ -533,7 +594,7 @@ var _ = Describe("StackitCluster Controller", func() { expectCondition(got.Status.Conditions, infrav1.ClusterBastionReadyCondition, metav1.ConditionFalse, "CloudInitRefError") }) - It("recreates the bastion and node SSH access when referenced cloud-init changes", func() { + It("recreates the bastion without tearing down security groups or public IP when referenced cloud-init changes", func() { got := &infrav1.StackitCluster{} Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) cloudInitName := "bastion-cloud-init-" + clusterName @@ -552,34 +613,100 @@ var _ = Describe("StackitCluster Controller", func() { Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) oldServerID := got.Status.Bastion.ServerID + oldBastionSGID := got.Status.Bastion.SecurityGroupID + oldPublicIPID := got.Status.Bastion.PublicIPID Expect(oldServerID).NotTo(BeEmpty()) - _, err = fakeCloud.EnsureNodeSSHAccess(ctx, cloud.NodeSSHAccessInput{ - Name: got.Name + "-node-ssh", - ServerID: got.Status.Bastion.ServerID, - BastionSecurityGroupID: got.Status.Bastion.SecurityGroupID, - Tags: bastionservice.NodeSSHAccessTags(got), - }) + Expect(oldBastionSGID).NotTo(BeEmpty()) + Expect(oldPublicIPID).NotTo(BeEmpty()) + Expect(fakeCloud.SecurityGroupCount()).To(Equal(2)) + nodeSG := fakeCloud.FindSecurityGroupByTags(scope.NodeSSHTags(got)) + Expect(nodeSG).NotTo(BeNil()) + + stackitMachine := newStackitMachine(got.Name+"-worker-0", got.Namespace, "worker-0") + stackitMachine.Spec.SecurityGroups = []string{nodeSG.ID} + machineScope, err := scope.NewMachineScope( + k8sClient, + &clusterv1.Cluster{ObjectMeta: metav1.ObjectMeta{Name: got.Name, Namespace: got.Namespace}}, + &clusterv1.Machine{ObjectMeta: metav1.ObjectMeta{Name: "worker-0", UID: "uid-1"}}, + got, + stackitMachine, + ) + Expect(err).NotTo(HaveOccurred()) + machineScope.SetCloudClient(fakeCloud) + Expect(server.New(machineScope).Reconcile(ctx)).To(Succeed()) + workerServerID := stackitMachine.Status.InstanceID + Expect(fakeCloud.ServerHasSecurityGroup(workerServerID, nodeSG.ID)).To(BeTrue()) + + configMap := &corev1.ConfigMap{} + Expect(k8sClient.Get(ctx, types.NamespacedName{Name: cloudInitName, Namespace: namespace}, configMap)).To(Succeed()) + configMap.Data["userData"] = "#cloud-config\npackages:\n- jq\n" + Expect(k8sClient.Update(ctx, configMap)).To(Succeed()) + + result, err = reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) + Expect(result.RequeueAfter).To(BeNumerically(">", 0)) + Expect(fakeCloud.ServerCount()).To(Equal(1)) + Expect(fakeCloud.PublicIPCount()).To(Equal(1)) Expect(fakeCloud.SecurityGroupCount()).To(Equal(2)) + Expect(fakeCloud.ServerHasSecurityGroup(workerServerID, nodeSG.ID)).To(BeTrue()) + + result, err = reconciler.Reconcile(ctx, request) + Expect(err).NotTo(HaveOccurred()) + Expect(result).To(Equal(reconcile.Result{})) + + Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) + Expect(got.Status.Bastion.ServerID).NotTo(BeEmpty()) + Expect(got.Status.Bastion.ServerID).NotTo(Equal(oldServerID)) + Expect(got.Status.Bastion.SecurityGroupID).To(Equal(oldBastionSGID)) + Expect(got.Status.Bastion.PublicIPID).To(Equal(oldPublicIPID)) + Expect(fakeCloud.ServerHasSecurityGroup(workerServerID, nodeSG.ID)).To(BeTrue()) + Expect(fakeCloud.ServerHasSecurityGroup(got.Status.Bastion.ServerID, oldBastionSGID)).To(BeTrue()) + Expect(fakeCloud.PublicIPAttachedToServer(oldPublicIPID, got.Status.Bastion.ServerID)).To(BeTrue()) + Expect(got.Status.Bastion.CloudInitHash).To(Equal(bastionCloudInitHash([]byte(configMap.Data["userData"])))) + Expect(string(fakeCloud.ServerUserData(got.Status.Bastion.ServerID))).To(Equal(configMap.Data["userData"])) + }) + + It("recreates the bastion when cloud-init changes even after bastion ServerID was lost from status", func() { + cloudInitName := "bastion-cloud-init-lost-id-" + clusterName + expectBastionCloudInit( + ctx, reconciler, request, stackitKey, fakeCloud, + "ConfigMap", cloudInitName, + "#cloud-config\npackages:\n- htop\n", createCloudInitConfigMap, + ) + + got := &infrav1.StackitCluster{} + Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) + oldServerID := got.Status.Bastion.ServerID + + By("losing Status.Bastion.ServerID while cloud-init changes") + got.Status.Bastion.ServerID = "" + Expect(k8sClient.Status().Update(ctx, got)).To(Succeed()) configMap := &corev1.ConfigMap{} Expect(k8sClient.Get(ctx, types.NamespacedName{Name: cloudInitName, Namespace: namespace}, configMap)).To(Succeed()) configMap.Data["userData"] = "#cloud-config\npackages:\n- jq\n" Expect(k8sClient.Update(ctx, configMap)).To(Succeed()) + By("adopting the existing server without overwriting CloudInitHash") + result, err := reconciler.Reconcile(ctx, request) + Expect(err).NotTo(HaveOccurred()) + Expect(result).To(Equal(reconcile.Result{})) + + Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) + Expect(got.Status.Bastion.ServerID).To(Equal(oldServerID)) + Expect(got.Status.Bastion.CloudInitHash).NotTo(Equal(bastionCloudInitHash([]byte(configMap.Data["userData"])))) + + By("detecting the cloud-init drift on the subsequent reconcile and recreating the bastion") result, err = reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) Expect(result.RequeueAfter).To(BeNumerically(">", 0)) Expect(fakeCloud.ServerCount()).To(Equal(0)) - Expect(fakeCloud.PublicIPCount()).To(Equal(0)) - Expect(fakeCloud.SecurityGroupCount()).To(Equal(0)) result, err = reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) Expect(result).To(Equal(reconcile.Result{})) Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) - Expect(got.Status.Bastion.ServerID).NotTo(BeEmpty()) Expect(got.Status.Bastion.ServerID).NotTo(Equal(oldServerID)) Expect(got.Status.Bastion.CloudInitHash).To(Equal(bastionCloudInitHash([]byte(configMap.Data["userData"])))) Expect(string(fakeCloud.ServerUserData(got.Status.Bastion.ServerID))).To(Equal(configMap.Data["userData"])) @@ -602,7 +729,7 @@ var _ = Describe("StackitCluster Controller", func() { }) It("marks conditions not ready when API server load balancer creation fails", func() { - fakeCloud.FailNextEnsureLB = fmt.Errorf("load balancer creation rejected: %w", cloud.ErrInvalidInput) + fakeCloud.FailNextEnsureLB = fmt.Errorf("load balancer creation rejected: %w", shared.ErrInvalidInput) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) @@ -620,7 +747,7 @@ var _ = Describe("StackitCluster Controller", func() { got.Spec.Bastion = validBastionSpec() Expect(k8sClient.Update(ctx, got)).To(Succeed()) - fakeCloud.FailNextEnsureBastion = fmt.Errorf("bastion creation rejected: %w", cloud.ErrInvalidInput) + fakeCloud.FailNextCreateServer = fmt.Errorf("bastion creation rejected: %w", shared.ErrInvalidInput) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) @@ -632,7 +759,7 @@ var _ = Describe("StackitCluster Controller", func() { }) It("requeues when network lookup returns a transient error", func() { - fakeCloud.FailNextGetNetwork = fmt.Errorf("temporary network lookup failure: %w", cloud.ErrTransient) + fakeCloud.FailNextGetNetwork = fmt.Errorf("temporary network lookup failure: %w", shared.ErrTransient) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) @@ -648,7 +775,7 @@ var _ = Describe("StackitCluster Controller", func() { // enqueues the cluster once the credentials are rejected. It("requeues on unauthorized credentials and recovers once they are corrected", func() { reconciler.CloudClientFactory = func(context.Context, cloud.Credentials) (cloud.Client, error) { - return nil, fmt.Errorf("authenticate: %w", cloud.ErrUnauthorized) + return nil, fmt.Errorf("authenticate: %w", shared.ErrUnauthorized) } result, err := reconciler.Reconcile(ctx, request) @@ -751,7 +878,7 @@ var _ = Describe("StackitCluster Controller", func() { Expect(k8sClient.Delete(ctx, got)).To(Succeed()) - fakeCloud.FailNextDeleteLB = fmt.Errorf("delete load balancer timeout: %w", cloud.ErrTransient) + fakeCloud.FailNextDeleteLB = fmt.Errorf("delete load balancer timeout: %w", shared.ErrTransient) _, err = reconciler.Reconcile(ctx, request) Expect(err).To(HaveOccurred()) @@ -842,7 +969,7 @@ var _ = Describe("StackitCluster Controller", func() { Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) Expect(got.Status.APIServerLoadBalancerID).NotTo(BeEmpty()) Expect(k8sClient.Delete(ctx, got)).To(Succeed()) - fakeCloud.FailNextDeleteLB = fmt.Errorf("delete load balancer: %w", cloud.ErrTransient) + fakeCloud.FailNextDeleteLB = fmt.Errorf("delete load balancer: %w", shared.ErrTransient) _, err = reconciler.Reconcile(ctx, request) Expect(err).To(HaveOccurred()) @@ -959,7 +1086,7 @@ var _ = Describe("StackitCluster Controller", func() { Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) Expect(got.Status.Ready).To(BeTrue()) - fakeCloud.FailNextSetTargets = fmt.Errorf("update target pool timeout: %w", cloud.ErrTransient) + fakeCloud.FailNextSetTargets = fmt.Errorf("update target pool timeout: %w", shared.ErrTransient) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) Expect(result.RequeueAfter).To(BeNumerically(">", 0)) @@ -975,7 +1102,7 @@ var _ = Describe("StackitCluster Controller", func() { It("requeues when the first target pool update fails permanently", func() { // Without the requeue nothing would drive another reconcile. createControlPlaneMachine(ctx, "cp-0-"+clusterName, clusterName, "10.0.0.11") - fakeCloud.FailNextSetTargets = fmt.Errorf("target pool rejected: %w", cloud.ErrInvalidInput) + fakeCloud.FailNextSetTargets = fmt.Errorf("target pool rejected: %w", shared.ErrInvalidInput) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) @@ -1089,8 +1216,25 @@ var _ = Describe("StackitCluster Controller", func() { })) }) + It("creates the bastion host in a single availability zone and not in metro (-m)", func() { + fakeCloud.AvailabilityZones = []string{"eu01-m", "eu01-3", "eu01-2"} + + got := &infrav1.StackitCluster{} + Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) + got.Spec.Bastion = validBastionSpec() + Expect(k8sClient.Update(ctx, got)).To(Succeed()) + + result, err := reconciler.Reconcile(ctx, request) + Expect(err).NotTo(HaveOccurred()) + Expect(result).To(Equal(reconcile.Result{})) + + Expect(fakeCloud.LastCreateServerInput.AvailabilityZone).To(Equal("eu01-2")) + Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) + Expect(got.Status.Bastion.ServerID).NotTo(BeEmpty()) + }) + It("reports an error condition when listing availability zones fails", func() { - fakeCloud.FailNextListAZ = fmt.Errorf("cloud failure: %w", cloud.ErrTransient) + fakeCloud.FailNextListAZ = fmt.Errorf("cloud failure: %w", shared.ErrTransient) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) diff --git a/controller/stackitcluster_infrastructure.go b/controller/stackitcluster_infrastructure.go deleted file mode 100644 index 19e9155..0000000 --- a/controller/stackitcluster_infrastructure.go +++ /dev/null @@ -1,601 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package controller - -import ( - "context" - "errors" - "fmt" - "net/netip" - "slices" - "strings" - "time" - - apierrors "k8s.io/apimachinery/pkg/api/errors" - "k8s.io/apimachinery/pkg/api/meta" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" - "sigs.k8s.io/cluster-api/util/collections" - "sigs.k8s.io/cluster-api/util/record" - ctrl "sigs.k8s.io/controller-runtime" - "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" - logf "sigs.k8s.io/controller-runtime/pkg/log" - - infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" - bastionservice "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/bastion" - loadbalancerservice "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" - networkservice "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" - "github.com/stackitcloud/cluster-api-provider-stackit/scope" - "github.com/stackitcloud/cluster-api-provider-stackit/util" -) - -func (r *StackitClusterReconciler) reconcileNormal(ctx context.Context, clusterScope *scope.ClusterScope) (ctrl.Result, error) { - log := logf.FromContext(ctx) - stackitCluster := clusterScope.StackitCluster - - if !controllerutil.ContainsFinalizer(stackitCluster, infrav1.ClusterFinalizer) { - controllerutil.AddFinalizer(stackitCluster, infrav1.ClusterFinalizer) - // Persisted immediately, before any cloud resource can be created, to - // ensure nothing is running behind an object that carries no finalizer to - // clean it up. - if err := clusterScope.PatchObject(ctx); err != nil { - return ctrl.Result{}, fmt.Errorf("persist finalizer: %w", err) - } - } - clusterScope.SetFailureDomains(stackitFailureDomains(stackitCluster.Spec.Region)) - - cloudClient, err := util.BuildCloudClient(ctx, r.Client, r.CloudClientFactory, stackitCluster) - if err != nil { - log.Error(err, "Failed to build cloud client for cluster", "cluster", stackitCluster.Name) - record.Warnf(stackitCluster, "InvalidCredentials", "Failed to build cloud client: %v", err) - stackitCluster.Status.Ready = false - return util.CredentialFailureResult( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - err, - credentialsRetryRequeueAfter, - infrav1.ClusterCredentialsReadyCondition, - infrav1.ClusterReadyCondition, - ) - } - clusterScope.SetConditions( - metav1.ConditionTrue, - "Available", - "", - infrav1.ClusterCredentialsReadyCondition, - ) - - zones, err := cloudClient.ListAvailabilityZones(ctx) - if err != nil { - stackitCluster.Status.Ready = false - return util.CloudFailureResult( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - "AvailabilityZonesError", - err, - retryableErrorRequeueAfter, - true, - infrav1.ClusterReadyCondition, - ) - } - clusterScope.SetFailureDomains(failureDomainsFromZones(stackitCluster.Spec.Region, zones)) - - network, result, err := r.ensureNetwork(ctx, cloudClient, clusterScope) - if err != nil || !result.IsZero() || network == nil { - return result, err - } - clusterScope.SetConditions( - metav1.ConditionTrue, - "Available", - "", - infrav1.ClusterNetworkReadyCondition, - ) - - if stackitCluster.Spec.APIServerLoadBalancer.Enabled { - // STACKIT takes an explicit target list rather than label-based - // membership, so exactly one reconciler owns the pool. Machines being - // deleted drop out here, before the node is drained. - machines, err := collections.GetFilteredMachinesForCluster( - ctx, - r.Client, - clusterScope.Cluster, - collections.ControlPlaneMachines(clusterScope.Cluster.Name), - collections.ActiveMachines, - ) - if err != nil { - util.SetConditions( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - metav1.ConditionFalse, - "MachineListError", - err.Error(), - infrav1.ClusterLoadBalancerReadyCondition, - ) - return ctrl.Result{}, fmt.Errorf("list control plane machines: %w", err) - } - targets := loadbalancerservice.APIServerTargets(machines.UnsortedList()) - - // Seeding with the real targets lets a load balancer deleted out of band - // come back with the control plane behind it. - seed := targets - if len(seed) == 0 { - seed = []cloud.LoadBalancerTargetInput{loadbalancerservice.BootstrapTarget(bootstrapTargetIP(network))} - } - loadBalancer, err := cloudClient.EnsureAPIServerLoadBalancer( - ctx, - loadbalancerservice.APIServerInput(clusterScope, seed), - ) - if err != nil { - log.Error(err, "Failed to create API server load balancer", - "cluster", stackitCluster.Name, - "region", stackitCluster.Spec.Region, - ) - record.Warnf( - stackitCluster, "FailedCreateLoadBalancer", - "Failed to create API server load balancer: %v", err, - ) - stackitCluster.Status.Ready = false - return util.CloudFailureResult( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - "LoadBalancerError", - err, - retryableErrorRequeueAfter, - false, - infrav1.ClusterLoadBalancerReadyCondition, - infrav1.ClusterReadyCondition, - ) - } - hadLoadBalancerID := stackitCluster.Status.APIServerLoadBalancerID != "" - if loadBalancer != nil { - stackitCluster.Status.APIServerLoadBalancerID = loadBalancer.ID - if !hadLoadBalancerID && loadBalancer.ID != "" { - record.Eventf( - stackitCluster, "LoadBalancerCreated", - "Created API server load balancer %s", loadBalancer.ID, - ) - } - } - if loadBalancer == nil || loadBalancer.IP == "" { - clusterScope.SetNotReady( - "Provisioning", - "waiting for API server load balancer IP address", - infrav1.ClusterLoadBalancerReadyCondition, - infrav1.ClusterReadyCondition, - ) - return ctrl.Result{RequeueAfter: 10 * time.Second}, nil - } - - isLBReady := meta.IsStatusConditionTrue(stackitCluster.Status.Conditions, infrav1.ClusterLoadBalancerReadyCondition) && - stackitCluster.Status.APIServerEndpoint.Host == loadBalancer.IP - - endpoint := clusterv1.APIEndpoint{ - Host: loadBalancer.IP, - Port: defaultAPIServerPort, - } - clusterScope.SetAPIServerEndpoint(endpoint) - - // An empty set never overwrites a populated pool: cluster deletion filters - // out every machine while the API server is still needed for drain. - if len(targets) > 0 { - if err := cloudClient.SetAPIServerLoadBalancerTargets(ctx, loadBalancer.ID, defaultAPIServerPort, targets); err != nil { - if !cloud.IsRetryable(err) { - record.Warnf( - stackitCluster, "LoadBalancerTargetError", - "Cannot update API server load balancer target pool: %v", err, - ) - } - // Scoped to the load balancer condition: failing the cluster would - // stop the machine reconciler from replacing the broken machine. - util.SetConditions( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - metav1.ConditionFalse, - "LoadBalancerTargetError", - err.Error(), - infrav1.ClusterLoadBalancerReadyCondition, - ) - // Requeue even on a permanent error: this return skips SetReady, so - // no machine exists yet whose events could retry it. - return ctrl.Result{RequeueAfter: retryableErrorRequeueAfter}, nil - } - log.V(1).Info("Reconciled API server load balancer target pool", "targets", len(targets)) - } - - if !isLBReady { - clusterScope.SetConditions( - metav1.ConditionTrue, - "Available", - "", - infrav1.ClusterLoadBalancerReadyCondition, - ) - record.Eventf( - stackitCluster, "LoadBalancerReady", - "API server load balancer is ready at %s", loadBalancer.IP, - ) - } - } else if stackitCluster.Spec.ControlPlaneEndpoint.Host != "" { - stackitCluster.Status.APIServerEndpoint = stackitCluster.Spec.ControlPlaneEndpoint - clusterScope.SetConditions( - metav1.ConditionTrue, - "Skipped", - "external endpoint provided", - infrav1.ClusterLoadBalancerReadyCondition, - ) - } else { - log.Error(errors.New("controlPlaneEndpoint host is empty"), "API server load balancer is disabled and controlPlaneEndpoint is empty", "cluster", stackitCluster.Name) - record.Warn(stackitCluster, "EndpointMissing", "apiServerLoadBalancer.enabled is false and controlPlaneEndpoint is empty") - clusterScope.SetNotReady( - "EndpointMissing", - "apiServerLoadBalancer.enabled is false and controlPlaneEndpoint is empty", - infrav1.ClusterLoadBalancerReadyCondition, - infrav1.ClusterReadyCondition, - ) - return ctrl.Result{}, nil - } - - if result, ready, err := r.reconcileBastion(ctx, cloudClient, clusterScope); err != nil { - log.Error(err, "Failed to reconcile bastion", - "cluster", stackitCluster.Name, - ) - record.Warnf( - stackitCluster, "FailedCreateBastion", - "Failed to reconcile bastion: %v", err, - ) - stackitCluster.Status.Ready = false - return util.CloudFailureResult( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - "BastionError", - err, - retryableErrorRequeueAfter, - false, - infrav1.ClusterBastionReadyCondition, - infrav1.ClusterReadyCondition, - ) - } else if !ready { - return result, nil - } - - clusterScope.SetReady() - log.V(1).Info("StackitCluster ready", "endpoint", stackitCluster.Status.APIServerEndpoint) - return ctrl.Result{}, nil -} - -func failureDomainsFromZones(region string, zones []string) []clusterv1.FailureDomain { - controlPlane := true - failureDomains := make([]clusterv1.FailureDomain, 0, len(zones)) - for _, zone := range zones { - // Filter out virtual/metro zones (such as eu01-m or any zone with suffix -m) - if strings.HasSuffix(zone, "-m") { - continue - } - failureDomains = append(failureDomains, clusterv1.FailureDomain{ - Name: zone, - ControlPlane: &controlPlane, - Attributes: map[string]string{ - "region": region, - }, - }) - } - if len(failureDomains) == 0 { - return stackitFailureDomains(region) - } - slices.SortFunc(failureDomains, func(a, b clusterv1.FailureDomain) int { - return strings.Compare(a.Name, b.Name) - }) - return failureDomains -} - -func stackitFailureDomains(region string) []clusterv1.FailureDomain { - controlPlane := true - return []clusterv1.FailureDomain{ - { - Name: region + "-1", - ControlPlane: &controlPlane, - Attributes: map[string]string{ - "region": region, - }, - }, - { - Name: region + "-2", - ControlPlane: &controlPlane, - Attributes: map[string]string{ - "region": region, - }, - }, - { - Name: region + "-3", - ControlPlane: &controlPlane, - Attributes: map[string]string{ - "region": region, - }, - }, - } -} - -func bootstrapTargetIP(network *cloud.Network) string { - if network == nil { - return "10.0.0.1" - } - for _, prefixValue := range network.IPv4Prefixes { - prefix, err := netip.ParsePrefix(prefixValue) - if err != nil || !prefix.Addr().Is4() { - continue - } - address := prefix.Masked().Addr() - for range 10 { - address = address.Next() - } - if prefix.Contains(address) { - return address.String() - } - } - return "10.0.0.1" -} - -func (r *StackitClusterReconciler) ensureNetwork( - ctx context.Context, - cloudClient cloud.Client, - clusterScope *scope.ClusterScope, -) (*cloud.Network, ctrl.Result, error) { - if clusterScope.StackitCluster.Spec.Network.ID != "" { - return r.getUnmanagedNetwork(ctx, cloudClient, clusterScope) - } - return r.ensureManagedNetwork(ctx, cloudClient, clusterScope) -} - -func (r *StackitClusterReconciler) getUnmanagedNetwork( - ctx context.Context, - cloudClient cloud.Client, - clusterScope *scope.ClusterScope, -) (*cloud.Network, ctrl.Result, error) { - log := logf.FromContext(ctx) - stackitCluster := clusterScope.StackitCluster - - network, err := cloudClient.GetNetwork(ctx, stackitCluster.Spec.Network.ID) - if err != nil { - log.Error(err, "Failed to get network", - "networkID", stackitCluster.Spec.Network.ID, - "region", stackitCluster.Spec.Region, - ) - record.Warnf( - stackitCluster, "FailedGetNetwork", - "Failed to get network %s in region %s: %v", - stackitCluster.Spec.Network.ID, stackitCluster.Spec.Region, err, - ) - stackitCluster.Status.Ready = false - res, failureErr := util.CloudFailureResult( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - "NetworkNotFound", - err, - retryableErrorRequeueAfter, - false, - infrav1.ClusterNetworkReadyCondition, - infrav1.ClusterReadyCondition, - ) - return nil, res, failureErr - } - stackitCluster.Status.Network = infrav1.StackitNetworkStatus{ - ID: network.ID, - Managed: false, - } - - return network, ctrl.Result{}, nil -} - -func (r *StackitClusterReconciler) ensureManagedNetwork( - ctx context.Context, - cloudClient cloud.Client, - clusterScope *scope.ClusterScope, -) (*cloud.Network, ctrl.Result, error) { - log := logf.FromContext(ctx) - stackitCluster := clusterScope.StackitCluster - - var network *cloud.Network - var err error - if stackitCluster.Status.Network.ID != "" { - network, err = cloudClient.GetNetwork(ctx, stackitCluster.Status.Network.ID) - if err != nil && !cloud.IsNotFound(err) { - log.Error(err, "Failed to get managed network", - "networkID", stackitCluster.Status.Network.ID, - "region", stackitCluster.Spec.Region, - ) - record.Warnf( - stackitCluster, "FailedGetNetwork", - "Failed to get managed network %s in region %s: %v", - stackitCluster.Status.Network.ID, stackitCluster.Spec.Region, err, - ) - stackitCluster.Status.Ready = false - res, failureErr := util.CloudFailureResult( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - "NetworkError", - err, - retryableErrorRequeueAfter, - false, - infrav1.ClusterNetworkReadyCondition, - infrav1.ClusterReadyCondition, - ) - return nil, res, failureErr - } - } - - if network == nil { - networkInput := networkservice.Input(stackitCluster) - network, err = cloudClient.CreateNetwork(ctx, networkInput) - if err != nil { - log.Error(err, "Failed to create managed network", - "networkName", networkInput.Name, - "region", stackitCluster.Spec.Region, - ) - record.Warnf( - stackitCluster, "FailedCreateNetwork", - "Failed to create managed network %s in region %s: %v", - networkInput.Name, stackitCluster.Spec.Region, err, - ) - stackitCluster.Status.Ready = false - res, failureErr := util.CloudFailureResult( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - "NetworkCreateError", - err, - retryableErrorRequeueAfter, - false, - infrav1.ClusterNetworkReadyCondition, - infrav1.ClusterReadyCondition, - ) - return nil, res, failureErr - } - record.Eventf(stackitCluster, "NetworkCreated", "Created managed network %s", network.ID) - } - - stackitCluster.Status.Network = infrav1.StackitNetworkStatus{ - ID: network.ID, - Managed: true, - } - - return network, ctrl.Result{}, nil -} - -func (r *StackitClusterReconciler) reconcileDelete(ctx context.Context, clusterScope *scope.ClusterScope) (ctrl.Result, error) { - log := logf.FromContext(ctx) - stackitCluster := clusterScope.StackitCluster - - // Machines resolve their credentials and project context through this - // StackitCluster, so the finalizer has to stay while any of them remain. - machines, err := collections.GetFilteredMachinesForCluster(ctx, r.Client, clusterScope.Cluster) - if err != nil { - log.Error(err, "Failed to list Machines for cluster during deletion", "cluster", clusterScope.Cluster.Name) - record.Warnf(stackitCluster, "FailedListMachines", - "Failed to list Machines for cluster %s: %v", clusterScope.Cluster.Name, err) - return ctrl.Result{}, fmt.Errorf("list Machines for cluster %s: %w", clusterScope.Cluster.Name, err) - } - if machines.Len() > 0 { - log.Info( - "Waiting for Machines to be deleted before removing the StackitCluster finalizer", - "remainingMachines", machines.Len(), - ) - return ctrl.Result{RequeueAfter: deleteRequeueAfter}, nil - } - - // Cleanup runs unconditionally: neither spec nor status is a trustworthy - // record of what exists in the cloud. ResolveID, DeleteBastion and - // DeleteNodeSSHAccess fall back to tag lookups and tolerate NotFound. - cloudClient, err := util.BuildCloudClient(ctx, r.Client, r.CloudClientFactory, stackitCluster) - if err != nil { - // A missing credentials Secret cannot be recovered from and commonly - // disappears first during namespace teardown, so finalize and make the - // possible leak loud rather than stranding the cluster in Terminating. - // Every other credentials problem is fixable and keeps retrying. - if apierrors.IsNotFound(err) { - log.Error(err, "Credentials secret is gone; finalizing without cloud cleanup", "cluster", stackitCluster.Name) - record.Warnf(stackitCluster, "CleanupSkipped", - "Credentials Secret is gone; finalizing without cloud cleanup. "+ - "Any remaining STACKIT resources for this cluster must be removed manually: %v", err) - controllerutil.RemoveFinalizer(stackitCluster, infrav1.ClusterFinalizer) - return ctrl.Result{}, nil - } - log.Error(err, "Failed to build cloud client for cluster deletion", "cluster", stackitCluster.Name) - record.Warnf(stackitCluster, "InvalidCredentials", - "Failed to build cloud client for deletion: %v", err) - util.SetConditions( - &stackitCluster.Status.Conditions, - stackitCluster.Generation, - metav1.ConditionFalse, - "CredentialsInvalid", - err.Error(), - infrav1.ClusterCredentialsReadyCondition, - ) - return ctrl.Result{}, err - } - loadBalancerID, err := loadbalancerservice.ResolveID(ctx, cloudClient, stackitCluster) - if err != nil { - log.Error(err, "Failed to resolve API server load balancer for deletion", "cluster", stackitCluster.Name) - record.Warnf(stackitCluster, "FailedResolveLoadBalancer", - "Failed to resolve API server load balancer: %v", err) - return ctrl.Result{}, err - } - if loadBalancerID != "" { - if err := cloudClient.DeleteAPIServerLoadBalancer(ctx, loadBalancerID); err != nil && !cloud.IsNotFound(err) { - log.Error(err, "Failed to delete API server load balancer", "cluster", stackitCluster.Name, "loadBalancerID", loadBalancerID) - record.Warnf(stackitCluster, "FailedDeleteLoadBalancer", - "Failed to delete API server load balancer %s: %v", loadBalancerID, err) - return ctrl.Result{}, err - } - stackitCluster.Status.APIServerLoadBalancerID = "" - record.Eventf( - stackitCluster, "LoadBalancerDeleted", - "Deleted API server load balancer %s", loadBalancerID, - ) - } - if err := cloudClient.DeleteNodeSSHAccess(ctx, bastionservice.NodeSSHAccessTags(stackitCluster)); err != nil && !cloud.IsNotFound(err) { - log.Error(err, "Failed to delete bastion node SSH access", "cluster", stackitCluster.Name) - record.Warnf(stackitCluster, "FailedDeleteNodeSSHAccess", - "Failed to delete bastion node SSH access: %v", err) - return ctrl.Result{}, err - } - if err := cloudClient.DeleteBastion(ctx, bastionservice.Input(clusterScope, nil), cloud.Bastion{ - ServerID: stackitCluster.Status.Bastion.ServerID, - PublicIPID: stackitCluster.Status.Bastion.PublicIPID, - PublicIP: stackitCluster.Status.Bastion.PublicIP, - SecurityGroupID: stackitCluster.Status.Bastion.SecurityGroupID, - }); err != nil && !cloud.IsNotFound(err) { - log.Error(err, "Failed to delete bastion", "cluster", stackitCluster.Name) - record.Warnf(stackitCluster, "FailedDeleteBastion", - "Failed to delete bastion: %v", err) - return ctrl.Result{}, err - } - if hasBastionStatus(stackitCluster.Status.Bastion) { - clusterScope.ClearBastionStatus() - record.Event(stackitCluster, "BastionDeleted", "Deleted bastion") - } - managedNetworkID, err := networkservice.ResolveManagedNetworkID(ctx, cloudClient, stackitCluster) - if err != nil { - log.Error(err, "Failed to resolve managed network for deletion", "cluster", stackitCluster.Name) - record.Warnf(stackitCluster, "FailedResolveNetwork", - "Failed to resolve managed network: %v", err) - return ctrl.Result{}, err - } - if managedNetworkID != "" { - if err := cloudClient.DeleteNetwork(ctx, managedNetworkID); err != nil && !cloud.IsNotFound(err) { - if cloud.IsConflict(err) { - log.Info("Managed network still has resources attached; requeueing deletion", - "cluster", stackitCluster.Name, - "networkID", managedNetworkID, - ) - clusterScope.SetConditions( - metav1.ConditionFalse, - "NetworkInUse", - err.Error(), - infrav1.ClusterNetworkReadyCondition, - ) - record.Warnf(stackitCluster, "NetworkInUse", - "Managed network %s still has active resources attached; retrying deletion: %v", managedNetworkID, err) - return ctrl.Result{RequeueAfter: deleteRequeueAfter}, nil - } - log.Error(err, "Failed to delete managed network", - "cluster", stackitCluster.Name, - "networkID", managedNetworkID, - ) - record.Warnf(stackitCluster, "FailedDeleteNetwork", - "Failed to delete managed network %s: %v", managedNetworkID, err) - return ctrl.Result{}, err - } - record.Eventf(stackitCluster, "NetworkDeleted", "Deleted managed network %s", managedNetworkID) - stackitCluster.Status.Network = infrav1.StackitNetworkStatus{} - } - - controllerutil.RemoveFinalizer(stackitCluster, infrav1.ClusterFinalizer) - return ctrl.Result{}, nil -} diff --git a/controller/stackitmachine_controller.go b/controller/stackitmachine_controller.go index 30688dd..b8b5de4 100644 --- a/controller/stackitmachine_controller.go +++ b/controller/stackitmachine_controller.go @@ -18,20 +18,31 @@ package controller import ( "context" + "errors" "fmt" + "time" corev1 "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/types" clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" clusterutil "sigs.k8s.io/cluster-api/util" + "sigs.k8s.io/cluster-api/util/collections" + "sigs.k8s.io/cluster-api/util/record" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/handler" logf "sigs.k8s.io/controller-runtime/pkg/log" + "sigs.k8s.io/controller-runtime/pkg/reconcile" infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" "github.com/stackitcloud/cluster-api-provider-stackit/cloud" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" "github.com/stackitcloud/cluster-api-provider-stackit/scope" "github.com/stackitcloud/cluster-api-provider-stackit/util" ) @@ -45,6 +56,17 @@ type StackitMachineReconciler struct { CloudClientFactory cloud.Factory } +// SetupWithManager registers the controller with the manager. +func (r *StackitMachineReconciler) SetupWithManager(mgr ctrl.Manager) error { + return ctrl.NewControllerManagedBy(mgr). + For(&infrav1.StackitMachine{}). + Watches(&clusterv1.Machine{}, handler.EnqueueRequestsFromMapFunc(r.stackitMachineRequestsForMachine)). + Watches(&infrav1.StackitCluster{}, handler.EnqueueRequestsFromMapFunc(r.stackitMachineRequestsForStackitCluster)). + Watches(&corev1.Secret{}, handler.EnqueueRequestsFromMapFunc(r.stackitMachineRequestsForBootstrapSecret)). + Named("stackitmachine"). + Complete(r) +} + // +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=stackitmachines,verbs=get;list;watch;create;update;patch;delete // +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=stackitmachines/status,verbs=get;update;patch // +kubebuilder:rbac:groups=infrastructure.cluster.x-k8s.io,resources=stackitmachines/finalizers,verbs=update @@ -53,6 +75,7 @@ type StackitMachineReconciler struct { // +kubebuilder:rbac:groups=cluster.x-k8s.io,resources=machines,verbs=get;list;watch // +kubebuilder:rbac:groups="",resources=secrets,verbs=get;list;watch // +kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch +// +kubebuilder:rbac:groups="",resources=events,verbs=create;patch func (r *StackitMachineReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, err error) { log := logf.FromContext(ctx) @@ -103,10 +126,10 @@ func (r *StackitMachineReconciler) Reconcile(ctx context.Context, req ctrl.Reque }() if paused, message := util.ReconciliationPaused(cluster, stackitMachine); paused { - util.SetPausedCondition(&stackitMachine.Status.Conditions, stackitMachine.Generation, true, message) + machineScope.SetPausedCondition(true, message) return ctrl.Result{}, nil } - util.SetPausedCondition(&stackitMachine.Status.Conditions, stackitMachine.Generation, false, "") + machineScope.SetPausedCondition(false, "") if !stackitMachine.DeletionTimestamp.IsZero() { return ctrl.Result{}, r.reconcileDelete(ctx, machineScope) @@ -114,13 +137,329 @@ func (r *StackitMachineReconciler) Reconcile(ctx context.Context, req ctrl.Reque return r.reconcileNormal(ctx, machineScope) } -// SetupWithManager registers the controller with the manager. -func (r *StackitMachineReconciler) SetupWithManager(mgr ctrl.Manager) error { - return ctrl.NewControllerManagedBy(mgr). - For(&infrav1.StackitMachine{}). - Watches(&clusterv1.Machine{}, handler.EnqueueRequestsFromMapFunc(r.stackitMachineRequestsForMachine)). - Watches(&infrav1.StackitCluster{}, handler.EnqueueRequestsFromMapFunc(r.stackitMachineRequestsForStackitCluster)). - Watches(&corev1.Secret{}, handler.EnqueueRequestsFromMapFunc(r.stackitMachineRequestsForBootstrapSecret)). - Named("stackitmachine"). - Complete(r) +func (r *StackitMachineReconciler) reconcileNormal(ctx context.Context, machineScope *scope.MachineScope) (ctrl.Result, error) { + log := logf.FromContext(ctx) + stackitMachine := machineScope.StackitMachine + + if !controllerutil.ContainsFinalizer(stackitMachine, infrav1.MachineFinalizer) { + controllerutil.AddFinalizer(stackitMachine, infrav1.MachineFinalizer) + // Persisted immediately, before CreateServer can run, to ensure no servers + // are running behind an object that carries no finalizer to clean it up. + if err := machineScope.PatchObject(ctx); err != nil { + return ctrl.Result{}, fmt.Errorf("persist finalizer: %w", err) + } + } + + if !machineScope.StackitCluster.Status.Ready { + log.Info("Waiting for StackitCluster to be ready", "machine", stackitMachine.Name, "cluster", machineScope.StackitCluster.Name) + machineScope.SetNotReady("InfrastructureNotReady", "waiting for StackitCluster to be ready", infrav1.MachineReadyCondition) + return ctrl.Result{}, nil + } + if err := validateMachineAvailabilityZone(machineScope); err != nil { + log.Error(err, "Invalid availability zone for machine", "machine", stackitMachine.Name, "availabilityZone", stackitMachine.Spec.AvailabilityZone) + record.Warnf(stackitMachine, "InvalidFailureDomain", "%v", err) + machineScope.SetNotReady( + "InvalidFailureDomain", + err.Error(), + infrav1.MachineInstanceReadyCondition, + infrav1.MachineReadyCondition, + ) + return ctrl.Result{}, nil + } + + bootstrapData, conditionStatus, reason, message := r.fetchBootstrapData(ctx, machineScope.Machine) + machineScope.SetConditions(conditionStatus, reason, message, infrav1.MachineBootstrapReadyCondition) + if conditionStatus != metav1.ConditionTrue { + log.Error(errors.New(message), "Bootstrap data is not ready", "machine", stackitMachine.Name, "reason", reason) + record.Warnf(stackitMachine, reason, "Bootstrap data error: %s", message) + machineScope.SetConditions(metav1.ConditionFalse, reason, message, infrav1.MachineReadyCondition) + if reason == util.BootstrapReasonInvalid { + return ctrl.Result{}, nil + } + return ctrl.Result{RequeueAfter: retryableErrorRequeueAfter}, nil + } + + cloudClient, err := util.BuildCloudClient(ctx, r.Client, r.CloudClientFactory, machineScope.StackitCluster) + if err != nil { + log.Error(err, "Failed to build cloud client for machine", "machine", stackitMachine.Name) + record.Warnf(stackitMachine, "InvalidCredentials", "Failed to build cloud client: %v", err) + return machineScope.CredentialFailureResult( + err, + credentialsRetryRequeueAfter, + infrav1.MachineCredentialsReadyCondition, + infrav1.MachineReadyCondition, + ) + } + machineScope.SetCloudClient(cloudClient) + machineScope.SetConditions(metav1.ConditionTrue, "Available", "", infrav1.MachineCredentialsReadyCondition) + + machineScope.SetBootstrapData(bootstrapData) + err = server.New(machineScope).Reconcile(ctx) + if server.IsServerGone(err) { + machineScope.SetNotReady( + "InstanceNotFound", + err.Error(), + infrav1.MachineInstanceReadyCondition, + infrav1.MachineReadyCondition, + ) + record.Warnf( + stackitMachine, "InstanceNotFound", + "Server %s no longer exists; the Machine must be replaced", stackitMachine.Status.InstanceID, + ) + return ctrl.Result{}, nil + } + if err != nil { + log.Error(err, "Failed to create server", + "machine", stackitMachine.Name, + "imageID", stackitMachine.Spec.ImageID, + "networkID", machineScope.NetworkID(), + "region", machineScope.StackitCluster.Spec.Region, + ) + record.Warnf( + stackitMachine, "FailedCreateInstance", + "Failed to create server %s (imageID: %s, networkID: %s, region: %s): %v", + stackitMachine.Name, stackitMachine.Spec.ImageID, machineScope.NetworkID(), + machineScope.StackitCluster.Spec.Region, err, + ) + return machineScope.CloudFailureResult( + "InstanceError", + err, + retryableErrorRequeueAfter, + true, + infrav1.MachineInstanceReadyCondition, + infrav1.MachineReadyCondition, + ) + } + if machineScope.InstanceCreated() { + record.Eventf( + stackitMachine, "InstanceCreated", "Created instance %s", stackitMachine.Status.InstanceID, + ) + } + + if ready, reason, message, warn := server.StateCondition(stackitMachine.Status.InstanceState, machineScope.InstancePowerStatus()); !ready { + previousReason := "" + if previous := meta.FindStatusCondition(stackitMachine.Status.Conditions, infrav1.MachineInstanceReadyCondition); previous != nil { + previousReason = previous.Reason + } + machineScope.SetNotReady(reason, message, infrav1.MachineInstanceReadyCondition, infrav1.MachineReadyCondition) + // Only warn on entering the state, not on every requeue. + if warn && previousReason != reason { + record.Warnf(stackitMachine, reason, "Server %s: %s", stackitMachine.Status.InstanceID, message) + } + return ctrl.Result{RequeueAfter: 15 * time.Second}, nil + } + + if err := securitygroup.New(machineScope).Reconcile(ctx); err != nil { + log.Error(err, "Failed to configure bastion SSH access for node", "machine", stackitMachine.Name) + record.Warnf( + stackitMachine, "FailedNodeSSHAccess", + "Failed to configure bastion SSH access for server %s: %v", stackitMachine.Status.InstanceID, err, + ) + return machineScope.CloudFailureResult( + "BastionSSHAccessError", + err, + retryableErrorRequeueAfter, + true, + infrav1.MachineReadyCondition, + ) + } + + machineScope.SetReady() + log.V(1).Info("Reconciled StackitMachine", "providerID", stackitMachine.Status.ProviderID) + return ctrl.Result{}, nil +} + +func validateMachineAvailabilityZone(machineScope *scope.MachineScope) error { + clusterFailureDomains := machineScope.StackitCluster.Status.FailureDomains + if len(clusterFailureDomains) == 0 { + return nil + } + knownAZ := func(zone string) bool { + for _, failureDomain := range clusterFailureDomains { + if failureDomain.Name == zone { + return true + } + } + return false + } + if az := machineScope.StackitMachine.Spec.AvailabilityZone; az != "" && !knownAZ(az) { + return fmt.Errorf("availabilityZone %q is not published in StackitCluster status.failureDomains", az) + } + if machineScope.Machine != nil && machineScope.Machine.Spec.FailureDomain != "" { + fd := machineScope.Machine.Spec.FailureDomain + if !knownAZ(fd) { + return fmt.Errorf("machine failureDomain %q is not published in StackitCluster status.failureDomains", fd) + } + } + return nil +} + +func (r *StackitMachineReconciler) reconcileDelete(ctx context.Context, machineScope *scope.MachineScope) error { + log := logf.FromContext(ctx) + stackitMachine := machineScope.StackitMachine + + // An empty status.instanceID is not proof that no server exists, so every + // deletion asks the cloud before dropping the finalizer. + cloudClient, err := util.BuildCloudClient(ctx, r.Client, r.CloudClientFactory, machineScope.StackitCluster) + if err != nil { + // A missing credentials Secret cannot be recovered from and commonly + // disappears first during namespace teardown, so finalize and make the + // possible leak loud rather than stranding the Machine in Terminating. + // Every other credentials problem is fixable and keeps retrying. + if apierrors.IsNotFound(err) { + log.Error(err, "Credentials secret is gone; finalizing without cloud cleanup", "machine", stackitMachine.Name) + record.Warnf(stackitMachine, "CleanupSkipped", + "Credentials Secret is gone; finalizing without cloud cleanup. "+ + "Any remaining STACKIT server for this machine must be removed manually: %v", err) + controllerutil.RemoveFinalizer(stackitMachine, infrav1.MachineFinalizer) + return nil + } + log.Error(err, "Failed to build cloud client for machine deletion", "machine", stackitMachine.Name) + record.Warnf(stackitMachine, "InvalidCredentials", + "Failed to build cloud client for deletion: %v", err) + _, resultErr := machineScope.CredentialFailureResult( + err, + credentialsRetryRequeueAfter, + infrav1.MachineCredentialsReadyCondition, + ) + return resultErr + } + + machineScope.SetCloudClient(cloudClient) + instanceID := stackitMachine.Status.InstanceID + if err := server.New(machineScope).Delete(ctx); err != nil { + log.Error(err, "Failed to delete server", "machine", stackitMachine.Name, "instanceID", instanceID) + record.Warnf(stackitMachine, "FailedDeleteInstance", + "Failed to delete server %s: %v", instanceID, err) + return err + } + if instanceID != "" { + record.Eventf( + stackitMachine, "InstanceDeleted", "Deleted instance %s", instanceID, + ) + } + controllerutil.RemoveFinalizer(stackitMachine, infrav1.MachineFinalizer) + return nil +} + +func (r *StackitMachineReconciler) fetchBootstrapData(ctx context.Context, machine *clusterv1.Machine) ([]byte, metav1.ConditionStatus, string, string) { + if machine.Spec.Bootstrap.DataSecretName == nil || *machine.Spec.Bootstrap.DataSecretName == "" { + return nil, metav1.ConditionFalse, "BootstrapDataSecretMissing", "Machine.spec.bootstrap.dataSecretName is empty" + } + secret := &corev1.Secret{} + key := types.NamespacedName{Namespace: machine.Namespace, Name: *machine.Spec.Bootstrap.DataSecretName} + if err := r.Get(ctx, key, secret); err != nil { + if apierrors.IsNotFound(err) { + return nil, metav1.ConditionFalse, "BootstrapDataSecretNotFound", fmt.Sprintf("bootstrap secret %s not found", key) + } + return nil, metav1.ConditionFalse, "BootstrapDataSecretError", err.Error() + } + data, err := util.ExtractBootstrapData(secret) + if err != nil { + return nil, metav1.ConditionFalse, util.BootstrapReasonInvalid, err.Error() + } + return data, metav1.ConditionTrue, "Available", "" +} + +func (r *StackitMachineReconciler) getStackitCluster(ctx context.Context, cluster *clusterv1.Cluster) (*infrav1.StackitCluster, error) { + if cluster.Spec.InfrastructureRef.Name == "" { + return nil, nil + } + stackitCluster := &infrav1.StackitCluster{} + key := types.NamespacedName{Namespace: cluster.Namespace, Name: cluster.Spec.InfrastructureRef.Name} + if err := r.Get(ctx, key, stackitCluster); err != nil { + if apierrors.IsNotFound(err) { + return nil, nil + } + return nil, fmt.Errorf("get StackitCluster %s: %w", key, err) + } + return stackitCluster, nil +} + +func (r *StackitMachineReconciler) stackitMachineRequestsForMachine(_ context.Context, obj client.Object) []reconcile.Request { + machine, ok := obj.(*clusterv1.Machine) + if !ok { + return nil + } + return stackitMachineRequestForMachine(machine) +} + +func (r *StackitMachineReconciler) stackitMachineRequestsForStackitCluster(ctx context.Context, obj client.Object) []reconcile.Request { + stackitCluster, ok := obj.(*infrav1.StackitCluster) + if !ok { + return nil + } + + // Machine.spec.clusterName names the owning Cluster, not the StackitCluster, + // and a ClusterClass-generated infrastructureRef never shares its name. + cluster, err := clusterutil.GetOwnerCluster(ctx, r.Client, stackitCluster.ObjectMeta) + switch { + case apierrors.IsNotFound(err) || cluster == nil: + return nil + case err != nil: + logf.FromContext(ctx).Error(err, "Failed to get owning Cluster for StackitCluster watch", "stackitCluster", client.ObjectKeyFromObject(stackitCluster)) + return nil + } + + machines, err := collections.GetFilteredMachinesForCluster(ctx, r.Client, cluster) + if err != nil { + logf.FromContext(ctx).Error(err, "Failed to list Machines for StackitCluster watch", "stackitCluster", client.ObjectKeyFromObject(stackitCluster)) + return nil + } + + return stackitMachineRequestsForMachines(machines.UnsortedList(), func(machine *clusterv1.Machine) bool { + return machine.Spec.ClusterName == cluster.Name + }) +} + +func (r *StackitMachineReconciler) stackitMachineRequestsForBootstrapSecret(ctx context.Context, obj client.Object) []reconcile.Request { + secret, ok := obj.(*corev1.Secret) + if !ok { + return nil + } + + machines := &clusterv1.MachineList{} + if err := r.List(ctx, machines, client.InNamespace(secret.Namespace)); err != nil { + logf.FromContext(ctx).Error(err, "Failed to list Machines for bootstrap Secret watch", "secret", client.ObjectKeyFromObject(secret)) + return nil + } + + return stackitMachineRequestsForMachines(collections.FromMachineList(machines).UnsortedList(), func(machine *clusterv1.Machine) bool { + return machine.Spec.Bootstrap.DataSecretName != nil && + *machine.Spec.Bootstrap.DataSecretName == secret.Name + }) +} + +func stackitMachineRequestsForMachines(machines []*clusterv1.Machine, matches func(*clusterv1.Machine) bool) []reconcile.Request { + requests := make([]reconcile.Request, 0, len(machines)) + seen := map[types.NamespacedName]struct{}{} + for _, machine := range machines { + if !matches(machine) { + continue + } + for _, request := range stackitMachineRequestForMachine(machine) { + if _, ok := seen[request.NamespacedName]; ok { + continue + } + seen[request.NamespacedName] = struct{}{} + requests = append(requests, request) + } + } + return requests +} + +func stackitMachineRequestForMachine(machine *clusterv1.Machine) []reconcile.Request { + if machine == nil { + return nil + } + ref := machine.Spec.InfrastructureRef + if ref.APIGroup != infrav1.GroupVersion.Group || ref.Kind != "StackitMachine" || ref.Name == "" { + return nil + } + return []reconcile.Request{{ + NamespacedName: types.NamespacedName{ + Namespace: machine.Namespace, + Name: ref.Name, + }, + }} } diff --git a/controller/stackitmachine_controller_test.go b/controller/stackitmachine_controller_test.go index 0efd701..084b725 100644 --- a/controller/stackitmachine_controller_test.go +++ b/controller/stackitmachine_controller_test.go @@ -28,6 +28,9 @@ import ( infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" "github.com/stackitcloud/cluster-api-provider-stackit/cloud" cloudfake "github.com/stackitcloud/cluster-api-provider-stackit/cloud/fake" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" "github.com/stackitcloud/cluster-api-provider-stackit/util" ) @@ -58,7 +61,7 @@ var _ = Describe("StackitMachine Controller", func() { bootstrapName = fmt.Sprintf("bootstrap-%d", suffix) stackitKey = types.NamespacedName{Namespace: namespace, Name: stackitName} request = reconcile.Request{NamespacedName: stackitKey} - fakeCloud = cloudfake.New(cloud.Network{ID: testNetworkID, Name: "network"}) + fakeCloud = cloudfake.New(network.Network{ID: testNetworkID, Name: "network"}) reconciler = &StackitMachineReconciler{ Client: k8sClient, Scheme: k8sClient.Scheme(), @@ -153,7 +156,7 @@ var _ = Describe("StackitMachine Controller", func() { Expect(instanceID).NotTo(BeEmpty()) By("removing the server behind the provider's back") - Expect(fakeCloud.DeleteServer(ctx, instanceID)).To(Succeed()) + fakeCloud.DeleteServer(instanceID) Expect(fakeCloud.ServerCount()).To(Equal(0)) By("reconciling again") @@ -237,15 +240,44 @@ var _ = Describe("StackitMachine Controller", func() { got := &infrav1.StackitMachine{} Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) Expect(got.Status.Ready).To(BeTrue()) - Expect(fakeCloud.EnsureNodeSSHCalls).To(Equal(1)) - securityGroups, err := fakeCloud.ListSecurityGroupsByTags(ctx, map[string]string{ + Expect(fakeCloud.AddSecurityGroupCalls).To(Equal(1)) + securityGroup := fakeCloud.FindSecurityGroupByTags(map[string]string{ util.LabelClusterName: clusterName, util.LabelResourceRole: util.ResourceRoleNodeSSH, }) + Expect(securityGroup).NotTo(BeNil()) + Expect(fakeCloud.SecurityGroupRules(securityGroup.ID)).To(ConsistOf( + securitygroup.Rule{ + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: 22, + PortMax: 22, + RemoteSecurityGroupID: "bastion-sg", + }, + securitygroup.Rule{ + Direction: securitygroup.DirectionEgress, + }, + )) + Expect(fakeCloud.ServerHasSecurityGroup(got.Status.InstanceID, securityGroup.ID)).To(BeTrue()) + }) + + It("requeues when bastion is enabled and bastion security group does not exist yet", func() { + stackitCluster := &infrav1.StackitCluster{} + Expect(k8sClient.Get(ctx, types.NamespacedName{Name: clusterName, Namespace: namespace}, stackitCluster)).To(Succeed()) + stackitCluster.Spec.Bastion = validBastionSpec() + Expect(k8sClient.Update(ctx, stackitCluster)).To(Succeed()) + stackitCluster.Status.Ready = true + stackitCluster.Status.Bastion.SecurityGroupID = "" + Expect(k8sClient.Status().Update(ctx, stackitCluster)).To(Succeed()) + + result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) - Expect(securityGroups).To(HaveLen(1)) - Expect(fakeCloud.SecurityGroupRemoteSources(securityGroups[0].ID)).To(ConsistOf("bastion-sg")) - Expect(fakeCloud.ServerHasSecurityGroup(got.Status.InstanceID, securityGroups[0].ID)).To(BeTrue()) + Expect(result.RequeueAfter).To(BeNumerically(">", 0)) + + got := &infrav1.StackitMachine{} + Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) + Expect(got.Status.Ready).To(BeFalse()) + expectCondition(got.Status.Conditions, infrav1.MachineReadyCondition, metav1.ConditionFalse, "BastionSSHAccessError") }) It("marks conditions not ready when bastion node SSH access fails", func() { @@ -257,7 +289,7 @@ var _ = Describe("StackitMachine Controller", func() { stackitCluster.Status.Bastion.SecurityGroupID = "bastion-sg" Expect(k8sClient.Status().Update(ctx, stackitCluster)).To(Succeed()) - fakeCloud.FailNextEnsureNodeSSH = fmt.Errorf("node ssh access timeout: %w", cloud.ErrTransient) + fakeCloud.FailNextAddSecurityGroup = fmt.Errorf("node ssh access timeout: %w", shared.ErrTransient) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) @@ -351,7 +383,7 @@ var _ = Describe("StackitMachine Controller", func() { It("requeues on unauthorized credentials and recovers once they are corrected", func() { reconciler.CloudClientFactory = func(context.Context, cloud.Credentials) (cloud.Client, error) { - return nil, fmt.Errorf("authenticate: %w", cloud.ErrUnauthorized) + return nil, fmt.Errorf("authenticate: %w", shared.ErrUnauthorized) } result, err := reconciler.Reconcile(ctx, request) @@ -424,7 +456,7 @@ var _ = Describe("StackitMachine Controller", func() { }) It("requeues when server lookup returns a conflict", func() { - fakeCloud.FailNextFindServer = fmt.Errorf("multiple matching servers: %w", cloud.ErrConflict) + fakeCloud.FailNextFindServer = fmt.Errorf("multiple matching servers: %w", shared.ErrConflict) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) @@ -438,7 +470,7 @@ var _ = Describe("StackitMachine Controller", func() { }) It("requeues when VM creation returns a transient error", func() { - fakeCloud.FailNextCreateServer = fmt.Errorf("create server timeout: %w", cloud.ErrTransient) + fakeCloud.FailNextCreateServer = fmt.Errorf("create server timeout: %w", shared.ErrTransient) result, err := reconciler.Reconcile(ctx, request) Expect(err).NotTo(HaveOccurred()) @@ -452,7 +484,7 @@ var _ = Describe("StackitMachine Controller", func() { }) It("returns an error when VM creation is rejected", func() { - fakeCloud.FailNextCreateServer = fmt.Errorf("create server rejected: %w", cloud.ErrInvalidInput) + fakeCloud.FailNextCreateServer = fmt.Errorf("create server rejected: %w", shared.ErrInvalidInput) result, err := reconciler.Reconcile(ctx, request) Expect(err).To(HaveOccurred()) @@ -492,7 +524,7 @@ var _ = Describe("StackitMachine Controller", func() { Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) Expect(k8sClient.Delete(ctx, got)).To(Succeed()) - fakeCloud.FailNextDeleteServer = fmt.Errorf("delete server timeout: %w", cloud.ErrTransient) + fakeCloud.FailNextDeleteServer = fmt.Errorf("delete server timeout: %w", shared.ErrTransient) _, err = reconciler.Reconcile(ctx, request) Expect(err).To(HaveOccurred()) @@ -527,7 +559,7 @@ var _ = Describe("StackitMachine Controller", func() { Expect(instanceID).NotTo(BeEmpty()) By("removing the server behind the provider's back") - Expect(fakeCloud.DeleteServer(ctx, instanceID)).To(Succeed()) + fakeCloud.DeleteServer(instanceID) Expect(fakeCloud.ServerCount()).To(Equal(0)) By("reconciling into the terminal state") @@ -542,7 +574,7 @@ var _ = Describe("StackitMachine Controller", func() { By("deleting the object while the cloud reports the server as gone") // The fake deletes an unknown ID without an error, so the not-found answer // of the cloud must be injected. - fakeCloud.FailNextDeleteServer = fmt.Errorf("delete server: %w", cloud.ErrNotFound) + fakeCloud.FailNextDeleteServer = fmt.Errorf("delete server: %w", shared.ErrNotFound) Expect(k8sClient.Delete(ctx, degraded)).To(Succeed()) @@ -597,12 +629,12 @@ var _ = Describe("StackitMachine Controller", func() { got := &infrav1.StackitMachine{} Expect(k8sClient.Get(ctx, stackitKey, got)).To(Succeed()) - fakeCloud.FailNextDeleteServer = fmt.Errorf("delete server: %w", cloud.ErrTransient) + fakeCloud.FailNextDeleteServer = fmt.Errorf("delete server: %w", shared.ErrTransient) Expect(k8sClient.Delete(ctx, got)).To(Succeed()) _, err = reconciler.Reconcile(ctx, request) - Expect(err).To(MatchError(cloud.ErrTransient)) + Expect(err).To(MatchError(shared.ErrTransient)) Expect(fakeCloud.ServerCount()).To(Equal(1)) stillThere := &infrav1.StackitMachine{} Expect(k8sClient.Get(ctx, stackitKey, stillThere)).To(Succeed()) diff --git a/controller/stackitmachine_infrastructure.go b/controller/stackitmachine_infrastructure.go deleted file mode 100644 index 10b7010..0000000 --- a/controller/stackitmachine_infrastructure.go +++ /dev/null @@ -1,422 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package controller - -import ( - "context" - "errors" - "fmt" - "time" - - corev1 "k8s.io/api/core/v1" - apierrors "k8s.io/apimachinery/pkg/api/errors" - "k8s.io/apimachinery/pkg/api/meta" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/types" - clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" - "sigs.k8s.io/cluster-api/util/record" - ctrl "sigs.k8s.io/controller-runtime" - "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" - logf "sigs.k8s.io/controller-runtime/pkg/log" - - infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" - bastionservice "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/bastion" - "github.com/stackitcloud/cluster-api-provider-stackit/scope" - "github.com/stackitcloud/cluster-api-provider-stackit/util" -) - -var errInstanceGone = errors.New("instance gone") - -func (r *StackitMachineReconciler) reconcileNormal(ctx context.Context, machineScope *scope.MachineScope) (ctrl.Result, error) { - log := logf.FromContext(ctx) - stackitMachine := machineScope.StackitMachine - - if !controllerutil.ContainsFinalizer(stackitMachine, infrav1.MachineFinalizer) { - controllerutil.AddFinalizer(stackitMachine, infrav1.MachineFinalizer) - // Persisted immediately, before CreateServer can run, to ensure no servers - // are running behind an object that carries no finalizer to clean it up. - if err := machineScope.PatchObject(ctx); err != nil { - return ctrl.Result{}, fmt.Errorf("persist finalizer: %w", err) - } - } - - if !machineScope.StackitCluster.Status.Ready { - log.Info("Waiting for StackitCluster to be ready", "machine", stackitMachine.Name, "cluster", machineScope.StackitCluster.Name) - machineScope.SetNotReady("InfrastructureNotReady", "waiting for StackitCluster to be ready", infrav1.MachineReadyCondition) - return ctrl.Result{}, nil - } - if err := validateMachineAvailabilityZone(machineScope); err != nil { - log.Error(err, "Invalid availability zone for machine", "machine", stackitMachine.Name, "availabilityZone", stackitMachine.Spec.AvailabilityZone) - record.Warnf(stackitMachine, "InvalidFailureDomain", "%v", err) - machineScope.SetNotReady( - "InvalidFailureDomain", - err.Error(), - infrav1.MachineInstanceReadyCondition, - infrav1.MachineReadyCondition, - ) - return ctrl.Result{}, nil - } - - bootstrapData, conditionStatus, reason, message := r.fetchBootstrapData(ctx, machineScope.Machine) - machineScope.SetConditions(conditionStatus, reason, message, infrav1.MachineBootstrapReadyCondition) - if conditionStatus != metav1.ConditionTrue { - log.Error(errors.New(message), "Bootstrap data is not ready", "machine", stackitMachine.Name, "reason", reason) - record.Warnf(stackitMachine, reason, "Bootstrap data error: %s", message) - machineScope.SetConditions(metav1.ConditionFalse, reason, message, infrav1.MachineReadyCondition) - if reason == util.BootstrapReasonInvalid { - return ctrl.Result{}, nil - } - return ctrl.Result{RequeueAfter: retryableErrorRequeueAfter}, nil - } - - cloudClient, err := util.BuildCloudClient(ctx, r.Client, r.CloudClientFactory, machineScope.StackitCluster) - if err != nil { - log.Error(err, "Failed to build cloud client for machine", "machine", stackitMachine.Name) - record.Warnf(stackitMachine, "InvalidCredentials", "Failed to build cloud client: %v", err) - return util.CredentialFailureResult( - &stackitMachine.Status.Conditions, - stackitMachine.Generation, - err, - credentialsRetryRequeueAfter, - infrav1.MachineCredentialsReadyCondition, - infrav1.MachineReadyCondition, - ) - } - machineScope.SetConditions(metav1.ConditionTrue, "Available", "", infrav1.MachineCredentialsReadyCondition) - - server, created, err := r.ensureServer(ctx, cloudClient, machineScope, bootstrapData) - if errors.Is(err, errInstanceGone) { - machineScope.SetNotReady( - "InstanceNotFound", - err.Error(), - infrav1.MachineInstanceReadyCondition, - infrav1.MachineReadyCondition, - ) - record.Warnf( - stackitMachine, "InstanceNotFound", - "Server %s no longer exists; the Machine must be replaced", stackitMachine.Status.InstanceID, - ) - return ctrl.Result{}, nil - } - if err != nil { - log.Error(err, "Failed to create server", - "machine", stackitMachine.Name, - "imageID", stackitMachine.Spec.ImageID, - "networkID", machineScope.NetworkID(), - "region", machineScope.StackitCluster.Spec.Region, - ) - record.Warnf( - stackitMachine, "FailedCreateInstance", - "Failed to create server %s (imageID: %s, networkID: %s, region: %s): %v", - stackitMachine.Name, stackitMachine.Spec.ImageID, machineScope.NetworkID(), - machineScope.StackitCluster.Spec.Region, err, - ) - machineScope.SetNotReady( - "InstanceError", - err.Error(), - infrav1.MachineInstanceReadyCondition, - infrav1.MachineReadyCondition, - ) - return util.CloudFailureResult( - &stackitMachine.Status.Conditions, - stackitMachine.Generation, - "InstanceError", - err, - retryableErrorRequeueAfter, - true, - infrav1.MachineInstanceReadyCondition, - infrav1.MachineReadyCondition, - ) - } - if created { - record.Eventf( - stackitMachine, "InstanceCreated", "Created instance %s", server.ID, - ) - } - - stackitMachine.Status.InstanceState = server.State - stackitMachine.Status.Addresses = machineAddressesFromCloud(server.Addresses) - providerID := machineScope.SetInstance(server) - - if ready, reason, message, warn := serverStateCondition(server.State, server.PowerStatus); !ready { - previousReason := "" - if previous := meta.FindStatusCondition(stackitMachine.Status.Conditions, infrav1.MachineInstanceReadyCondition); previous != nil { - previousReason = previous.Reason - } - machineScope.SetNotReady(reason, message, infrav1.MachineInstanceReadyCondition, infrav1.MachineReadyCondition) - // Only warn on entering the state, not on every requeue. - if warn && previousReason != reason { - record.Warnf(stackitMachine, reason, "Server %s: %s", server.ID, message) - } - return ctrl.Result{RequeueAfter: 15 * time.Second}, nil - } - - if err := r.reconcileBastionNodeSSHAccess(ctx, cloudClient, machineScope, server); err != nil { - log.Error(err, "Failed to configure bastion SSH access for node", "machine", stackitMachine.Name) - record.Warnf( - stackitMachine, "FailedNodeSSHAccess", - "Failed to configure bastion SSH access for server %s: %v", server.ID, err, - ) - machineScope.SetNotReady("BastionSSHAccessError", err.Error(), infrav1.MachineReadyCondition) - return util.CloudFailureResult( - &stackitMachine.Status.Conditions, - stackitMachine.Generation, - "BastionSSHAccessError", - err, - retryableErrorRequeueAfter, - true, - infrav1.MachineReadyCondition, - ) - } - - machineScope.SetReady() - log.V(1).Info("StackitMachine ready", "providerID", providerID) - return ctrl.Result{}, nil -} - -func validateMachineAvailabilityZone(machineScope *scope.MachineScope) error { - clusterFailureDomains := machineScope.StackitCluster.Status.FailureDomains - if len(clusterFailureDomains) == 0 { - return nil - } - knownAZ := func(zone string) bool { - for _, failureDomain := range clusterFailureDomains { - if failureDomain.Name == zone { - return true - } - } - return false - } - if az := machineScope.StackitMachine.Spec.AvailabilityZone; az != "" && !knownAZ(az) { - return fmt.Errorf("availabilityZone %q is not published in StackitCluster status.failureDomains", az) - } - if machineScope.Machine != nil && machineScope.Machine.Spec.FailureDomain != "" { - fd := machineScope.Machine.Spec.FailureDomain - if !knownAZ(fd) { - return fmt.Errorf("machine failureDomain %q is not published in StackitCluster status.failureDomains", fd) - } - } - return nil -} - -func (r *StackitMachineReconciler) reconcileDelete(ctx context.Context, machineScope *scope.MachineScope) error { - log := logf.FromContext(ctx) - stackitMachine := machineScope.StackitMachine - - // An empty status.instanceID is not proof that no server exists, so every - // deletion asks the cloud before dropping the finalizer. - cloudClient, err := util.BuildCloudClient(ctx, r.Client, r.CloudClientFactory, machineScope.StackitCluster) - if err != nil { - // A missing credentials Secret cannot be recovered from and commonly - // disappears first during namespace teardown, so finalize and make the - // possible leak loud rather than stranding the Machine in Terminating. - // Every other credentials problem is fixable and keeps retrying. - if apierrors.IsNotFound(err) { - log.Error(err, "Credentials secret is gone; finalizing without cloud cleanup", "machine", stackitMachine.Name) - record.Warnf(stackitMachine, "CleanupSkipped", - "Credentials Secret is gone; finalizing without cloud cleanup. "+ - "Any remaining STACKIT server for this machine must be removed manually: %v", err) - controllerutil.RemoveFinalizer(stackitMachine, infrav1.MachineFinalizer) - return nil - } - log.Error(err, "Failed to build cloud client for machine deletion", "machine", stackitMachine.Name) - record.Warnf(stackitMachine, "InvalidCredentials", - "Failed to build cloud client for deletion: %v", err) - _, resultErr := util.CredentialFailureResult( - &stackitMachine.Status.Conditions, - stackitMachine.Generation, - err, - credentialsRetryRequeueAfter, - infrav1.MachineCredentialsReadyCondition, - ) - return resultErr - } - - instanceID, err := r.resolveServerForDeletion(ctx, cloudClient, machineScope) - if err != nil { - log.Error(err, "Failed to resolve server for deletion", "machine", stackitMachine.Name) - record.Warnf(stackitMachine, "FailedResolveInstance", - "Failed to resolve server for deletion: %v", err) - return err - } - if instanceID != "" { - if err := cloudClient.DeleteServer(ctx, instanceID); err != nil && !cloud.IsNotFound(err) { - log.Error(err, "Failed to delete server", "machine", stackitMachine.Name, "instanceID", instanceID) - record.Warnf(stackitMachine, "FailedDeleteInstance", - "Failed to delete server %s: %v", instanceID, err) - return err - } - machineScope.ClearInstance() - record.Eventf( - stackitMachine, "InstanceDeleted", "Deleted instance %s", instanceID, - ) - } - controllerutil.RemoveFinalizer(stackitMachine, infrav1.MachineFinalizer) - return nil -} - -// resolveServerForDeletion reports the ID of the server backing this machine, or -// an empty string once the cloud confirms none exists. It falls back to the tags, -// which carry the Machine UID, because a lost status patch can leave a running -// server that status.instanceID no longer names. -func (r *StackitMachineReconciler) resolveServerForDeletion( - ctx context.Context, - cloudClient cloud.Client, - machineScope *scope.MachineScope, -) (string, error) { - if instanceID := machineScope.StackitMachine.Status.InstanceID; instanceID != "" { - return instanceID, nil - } - server, err := cloudClient.FindServerByTags(ctx, machineScope.Tags()) - if err != nil { - if cloud.IsNotFound(err) { - return "", nil - } - return "", err - } - return server.ID, nil -} - -func (r *StackitMachineReconciler) fetchBootstrapData(ctx context.Context, machine *clusterv1.Machine) ([]byte, metav1.ConditionStatus, string, string) { - if machine.Spec.Bootstrap.DataSecretName == nil || *machine.Spec.Bootstrap.DataSecretName == "" { - return nil, metav1.ConditionFalse, "BootstrapDataSecretMissing", "Machine.spec.bootstrap.dataSecretName is empty" - } - secret := &corev1.Secret{} - key := types.NamespacedName{Namespace: machine.Namespace, Name: *machine.Spec.Bootstrap.DataSecretName} - if err := r.Get(ctx, key, secret); err != nil { - if apierrors.IsNotFound(err) { - return nil, metav1.ConditionFalse, "BootstrapDataSecretNotFound", fmt.Sprintf("bootstrap secret %s not found", key) - } - return nil, metav1.ConditionFalse, "BootstrapDataSecretError", err.Error() - } - data, err := util.ExtractBootstrapData(secret) - if err != nil { - return nil, metav1.ConditionFalse, util.BootstrapReasonInvalid, err.Error() - } - return data, metav1.ConditionTrue, "Available", "" -} - -func (r *StackitMachineReconciler) ensureServer( - ctx context.Context, - cloudClient cloud.Client, - machineScope *scope.MachineScope, - userData []byte, -) (*cloud.Server, bool, error) { - stackitMachine := machineScope.StackitMachine - tags := machineScope.Tags() - if stackitMachine.Status.InstanceID != "" { - server, err := cloudClient.GetServer(ctx, stackitMachine.Status.InstanceID) - if err == nil { - return server, false, nil - } - if !cloud.IsNotFound(err) { - return nil, false, err - } - } - if server, err := cloudClient.FindServerByTags(ctx, tags); err == nil { - return server, false, nil - } else if !cloud.IsNotFound(err) { - return nil, false, err - } - - // Recreating the server would replay bootstrap data pinned to the previous - // identity, so surface the loss and let Cluster API replace the Machine. - if stackitMachine.Status.Initialization.Provisioned { - return nil, false, fmt.Errorf( - "%w: server %s; the Machine must be replaced", - errInstanceGone, stackitMachine.Status.InstanceID, - ) - } - - networkID := machineScope.NetworkID() - if networkID == "" { - return nil, false, fmt.Errorf("%w: cluster network ID is not yet available", cloud.ErrTransient) - } - - deleteOnTermination := true - if stackitMachine.Spec.RootVolume.DeleteOnTermination != nil { - deleteOnTermination = *stackitMachine.Spec.RootVolume.DeleteOnTermination - } - server, err := cloudClient.CreateServer(ctx, cloud.CreateServerInput{ - Name: stackitMachine.Name, - ProjectID: machineScope.StackitCluster.Spec.ProjectID, - Region: machineScope.StackitCluster.Spec.Region, - ImageID: stackitMachine.Spec.ImageID, - MachineType: stackitMachine.Spec.MachineType, - AvailabilityZone: machineScope.AvailabilityZone(), - SSHKeyName: stackitMachine.Spec.SSHKeyName, - NetworkID: networkID, - SecurityGroups: stackitMachine.Spec.SecurityGroups, - UserData: userData, - Tags: tags, - RootVolume: cloud.RootVolumeInput{ - SizeGiB: stackitMachine.Spec.RootVolume.SizeGiB, - PerformanceClass: stackitMachine.Spec.RootVolume.PerformanceClass, - DeleteOnTermination: deleteOnTermination, - }, - }) - return server, true, err -} - -func (r *StackitMachineReconciler) reconcileBastionNodeSSHAccess( - ctx context.Context, - cloudClient cloud.Client, - machineScope *scope.MachineScope, - server *cloud.Server, -) error { - if !machineScope.StackitCluster.Spec.Bastion.Enabled { - return nil - } - if machineScope.StackitCluster.Status.Bastion.SecurityGroupID == "" { - return fmt.Errorf("%w: bastion security group ID is empty", cloud.ErrTransient) - } - if server == nil || server.ID == "" { - return fmt.Errorf("%w: server ID is empty", cloud.ErrTransient) - } - _, err := cloudClient.EnsureNodeSSHAccess(ctx, cloud.NodeSSHAccessInput{ - Name: machineScope.StackitCluster.Name + "-node-ssh", - ServerID: server.ID, - BastionSecurityGroupID: machineScope.StackitCluster.Status.Bastion.SecurityGroupID, - Tags: bastionservice.NodeSSHAccessTags(machineScope.StackitCluster), - }) - return err -} - -func (r *StackitMachineReconciler) getStackitCluster(ctx context.Context, cluster *clusterv1.Cluster) (*infrav1.StackitCluster, error) { - if cluster.Spec.InfrastructureRef.Name == "" { - return nil, nil - } - stackitCluster := &infrav1.StackitCluster{} - key := types.NamespacedName{Namespace: cluster.Namespace, Name: cluster.Spec.InfrastructureRef.Name} - if err := r.Get(ctx, key, stackitCluster); err != nil { - if apierrors.IsNotFound(err) { - return nil, nil - } - return nil, fmt.Errorf("get StackitCluster %s: %w", key, err) - } - return stackitCluster, nil -} - -func machineAddressesFromCloud(in []cloud.Address) []clusterv1.MachineAddress { - if len(in) == 0 { - return nil - } - - out := make([]clusterv1.MachineAddress, len(in)) - for i, address := range in { - out[i] = clusterv1.MachineAddress{ - Type: clusterv1.MachineAddressType(address.Type), - Address: address.Address, - } - } - return out -} diff --git a/controller/stackitmachine_watches.go b/controller/stackitmachine_watches.go deleted file mode 100644 index c8c9fbb..0000000 --- a/controller/stackitmachine_watches.go +++ /dev/null @@ -1,115 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package controller - -import ( - "context" - - corev1 "k8s.io/api/core/v1" - apierrors "k8s.io/apimachinery/pkg/api/errors" - "k8s.io/apimachinery/pkg/types" - clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" - clusterutil "sigs.k8s.io/cluster-api/util" - "sigs.k8s.io/cluster-api/util/collections" - "sigs.k8s.io/controller-runtime/pkg/client" - logf "sigs.k8s.io/controller-runtime/pkg/log" - "sigs.k8s.io/controller-runtime/pkg/reconcile" - - infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" -) - -func (r *StackitMachineReconciler) stackitMachineRequestsForMachine(_ context.Context, obj client.Object) []reconcile.Request { - machine, ok := obj.(*clusterv1.Machine) - if !ok { - return nil - } - return stackitMachineRequestForMachine(machine) -} - -func (r *StackitMachineReconciler) stackitMachineRequestsForStackitCluster(ctx context.Context, obj client.Object) []reconcile.Request { - stackitCluster, ok := obj.(*infrav1.StackitCluster) - if !ok { - return nil - } - - // Machine.spec.clusterName names the owning Cluster, not the StackitCluster, - // and a ClusterClass-generated infrastructureRef never shares its name. - cluster, err := clusterutil.GetOwnerCluster(ctx, r.Client, stackitCluster.ObjectMeta) - switch { - case apierrors.IsNotFound(err) || cluster == nil: - return nil - case err != nil: - logf.FromContext(ctx).Error(err, "Failed to get owning Cluster for StackitCluster watch", "stackitCluster", client.ObjectKeyFromObject(stackitCluster)) - return nil - } - - machines, err := collections.GetFilteredMachinesForCluster(ctx, r.Client, cluster) - if err != nil { - logf.FromContext(ctx).Error(err, "Failed to list Machines for StackitCluster watch", "stackitCluster", client.ObjectKeyFromObject(stackitCluster)) - return nil - } - - return stackitMachineRequestsForMachines(machines.UnsortedList(), func(machine *clusterv1.Machine) bool { - return machine.Spec.ClusterName == cluster.Name - }) -} - -func (r *StackitMachineReconciler) stackitMachineRequestsForBootstrapSecret(ctx context.Context, obj client.Object) []reconcile.Request { - secret, ok := obj.(*corev1.Secret) - if !ok { - return nil - } - - machines := &clusterv1.MachineList{} - if err := r.List(ctx, machines, client.InNamespace(secret.Namespace)); err != nil { - logf.FromContext(ctx).Error(err, "Failed to list Machines for bootstrap Secret watch", "secret", client.ObjectKeyFromObject(secret)) - return nil - } - - return stackitMachineRequestsForMachines(collections.FromMachineList(machines).UnsortedList(), func(machine *clusterv1.Machine) bool { - return machine.Spec.Bootstrap.DataSecretName != nil && - *machine.Spec.Bootstrap.DataSecretName == secret.Name - }) -} - -func stackitMachineRequestsForMachines(machines []*clusterv1.Machine, matches func(*clusterv1.Machine) bool) []reconcile.Request { - requests := make([]reconcile.Request, 0, len(machines)) - seen := map[types.NamespacedName]struct{}{} - for _, machine := range machines { - if !matches(machine) { - continue - } - for _, request := range stackitMachineRequestForMachine(machine) { - if _, ok := seen[request.NamespacedName]; ok { - continue - } - seen[request.NamespacedName] = struct{}{} - requests = append(requests, request) - } - } - return requests -} - -func stackitMachineRequestForMachine(machine *clusterv1.Machine) []reconcile.Request { - if machine == nil { - return nil - } - ref := machine.Spec.InfrastructureRef - if ref.APIGroup != infrav1.GroupVersion.Group || ref.Kind != "StackitMachine" || ref.Name == "" { - return nil - } - return []reconcile.Request{{ - NamespacedName: types.NamespacedName{ - Namespace: machine.Namespace, - Name: ref.Name, - }, - }} -} diff --git a/docs/src/development/architecture.md b/docs/src/development/architecture.md index 80c5327..3921315 100644 --- a/docs/src/development/architecture.md +++ b/docs/src/development/architecture.md @@ -2,11 +2,12 @@ ## Overview -The provider has four main areas: +The provider has five main areas: - API types and CRDs - Controllers -- Cloud abstraction layer +- Scopes (`ClusterScope` and `MachineScope`) +- Cloud client and resource services - clusterctl templates and release assets Key packages: @@ -14,16 +15,21 @@ Key packages: ```text api/v1alpha1/ Provider API types controller/ Reconciliation logic -cloud/ Cloud client interface and SDK implementation -cloud/fake/ In-memory fake for tests +scope/ Per-reconcile state, status patching, and service specs +cloud/ Cloud client factory, provider ID helpers, and tag-based cleanup +cloud/services/ Resource services (availabilityzone, network, loadbalancer, publicip, securitygroup, server, shared) +cloud/fake/ In-memory fake HTTP transport and client for tests util/ Shared helpers templates/ clusterctl templates config/ Kubebuilder manifests ``` -The controllers do not call the STACKIT SDK directly. They use the cloud client -interface, which keeps reconciliation testable and allows fake-client envtest -coverage. +Controllers construct a `ClusterScope` or `MachineScope` for each +reconciliation pass and delegate cloud operations to the resource services +under `cloud/services/`. Both the real `SDKClient` and `fake.Client` implement +`cloud.Client` (exposing the configured project ID, region, and STACKIT IaaS / +Load Balancer SDK clients), keeping reconciliation testable with envtest and +in-memory HTTP fakes. ## Cluster API Contract @@ -49,49 +55,74 @@ Important contract behavior: infrastructure cluster contract when the provider manages the API server load balancer endpoint. -## Controllers +## Controllers and Scopes + +`ClusterScope` (`scope/cluster_scope.go`) and `MachineScope` +(`scope/machine_scope.go`) hold the Kubernetes objects and cloud client for a +single reconcile pass, patch status and conditions on close, and translate +Kubernetes spec/status fields into service spec structs +(`AvailabilityZoneSpec`, `NetworkSpec`, `LoadBalancerSpec`, `PublicIPSpec`, +`SecurityGroupSpec`, `ServerSpec`). `StackitClusterReconciler` is responsible for: -- Reading credentials -- Looking up the configured network -- Managing the optional API server load balancer -- Maintaining its target pool from the control-plane machines of the cluster -- Publishing failure domains +- Reading credentials and building the cloud client +- Reconciling availability zones and publishing failure domains +- Reconciling the cluster network (validating a BYO network or creating a managed network) +- Reconciling the optional API server load balancer and its control-plane + target pool +- Reconciling the optional bastion host (server, security groups, and public IP) - Updating readiness and contract status -- Cleaning up provider-managed load balancers on deletion +- Cleaning up provider-managed bastion, load balancer, and network resources on deletion `StackitMachineReconciler` is responsible for: +- Validating the machine's availability zone against cluster failure domains - Waiting for bootstrap data -- Creating STACKIT servers -- Setting provider IDs and addresses -- Deleting servers on teardown +- Reconciling the STACKIT server instance, provider ID, and addresses +- Reconciling node SSH security group attachment when the bastion is enabled +- Deleting the server on teardown Reconciliation must be idempotent. Re-running the same reconcile loop should be safe and should not create duplicate cloud resources. -## Cloud Client +## Cloud Client and Services + +`cloud.Client` provides the project ID, region, and configured STACKIT IaaS +(`*iaas.APIClient`) and Load Balancer (`*lb.APIClient`) SDK clients. -The cloud client abstraction hides STACKIT SDK details from controllers. +Cloud resource management is organized into service packages under +`cloud/services/`: -It covers: +- `availabilityzone`: Lists availability zones (`Reconcile`) +- `network`: Validates BYO networks or creates, adopts by tags, and deletes + managed cluster networks (`Reconcile`, `Delete`) +- `loadbalancer`: Creates, adopts by tags, updates target pools, and deletes + the API server load balancer (`Reconcile`, `Delete`) +- `publicip`: Creates, adopts by tags, associates/disassociates, and deletes + public IPs (`Reconcile`, `Delete`) +- `securitygroup`: Creates, adopts by tags, reconciles rules and server + attachments, and deletes security groups (`Reconcile`, `Delete`) +- `server`: Creates, adopts by tags, inspects state/addresses, and deletes + servers (`Reconcile`, `Delete`) +- `shared`: Sentinel errors (`ErrNotFound`, `ErrUnauthorized`, + `ErrInvalidInput`, `ErrConflict`, `ErrTransient`), SDK error classification, + and tag lookup/deletion helpers -- Server create, get, list, and delete -- Network lookup -- Load balancer create, list, delete, and target-pool updates -- Provider ID helpers -- Error classification +`cloud.CleanupByTags` uses the `publicip`, `loadbalancer`, `server`, +`securitygroup`, and `network` services to delete all provider-managed +resources matching a tag selector without requiring Kubernetes objects. -Controllers should handle classified errors differently: +Controllers and scopes handle classified errors from `cloud/services/shared` +differently: -- transient errors should be retried -- terminal validation errors should set clear conditions -- not-found errors during deletion should be treated as successful cleanup where - appropriate +- transient and conflict errors (`shared.IsRetryable`) trigger a timed requeue +- terminal validation or credential errors set clear conditions +- not-found errors during deletion are treated as successful cleanup -Tests use an in-memory fake cloud client for deterministic reconciliation -coverage. SDK integration tests are opt-in and require real STACKIT credentials. +Tests use `cloud/fake.Client` (which backs the STACKIT SDK clients with an +in-memory HTTP handler) for deterministic unit and envtest coverage. SDK +integration tests are opt-in and require real STACKIT credentials. ## STACKIT ProviderID Compatibility @@ -101,7 +132,6 @@ repository. Relevant reference points: - `pkg/ccm/instances.go`: `Instances.makeInstanceID` returns `stackit://`. -- `pkg/ccm/instances.go`: `instanceIDFromProviderID` parses `stackit://` with no project or region component. - `pkg/ccm/instances.go`: `getInstance` resolves nodes with `GetServer(projectID, region, serverID)`, where project and region come from the cloud-controller-manager configuration. - `pkg/ccm/instances_test.go`: the "new providerID" table entry expects `stackit://hello-server`. diff --git a/docs/src/topics/failure-domains.md b/docs/src/topics/failure-domains.md index 113e1fb..79e2ad3 100644 --- a/docs/src/topics/failure-domains.md +++ b/docs/src/topics/failure-domains.md @@ -51,6 +51,11 @@ using the following precedence: The actual zone where the VM was placed is surfaced on `StackitMachine.status.availabilityZone`. +When `StackitCluster.spec.bastion.enabled` is `true`, the provider-managed bastion +host is also placed into the cluster's default availability zone (the first +sorted published failure domain, e.g., `eu01-1`) so it is never created in a +metro zone (`-m`). + ## Worker Node Spreading Unlike the control plane, worker nodes do not automatically spread across failure domains diff --git a/go.mod b/go.mod index dc54ea2..e140f31 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,7 @@ module github.com/stackitcloud/cluster-api-provider-stackit go 1.26 require ( + github.com/go-logr/logr v1.4.3 github.com/onsi/ginkgo/v2 v2.28.1 github.com/onsi/gomega v1.39.1 github.com/stackitcloud/stackit-sdk-go/core v0.26.0 @@ -30,7 +31,6 @@ require ( github.com/felixge/httpsnoop v1.0.4 // indirect github.com/fsnotify/fsnotify v1.9.0 // indirect github.com/fxamacker/cbor/v2 v2.9.0 // indirect - github.com/go-logr/logr v1.4.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-logr/zapr v1.3.0 // indirect github.com/go-openapi/jsonpointer v0.21.0 // indirect diff --git a/scope/cluster_scope.go b/scope/cluster_scope.go index 476d8e0..123c607 100644 --- a/scope/cluster_scope.go +++ b/scope/cluster_scope.go @@ -15,8 +15,15 @@ package scope import ( "context" + "errors" + "net/netip" + "slices" + "strings" + "time" + "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" @@ -24,14 +31,38 @@ import ( infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" "github.com/stackitcloud/cluster-api-provider-stackit/cloud" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/availabilityzone" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/publicip" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" "github.com/stackitcloud/cluster-api-provider-stackit/util" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" + lb "github.com/stackitcloud/stackit-sdk-go/services/loadbalancer/v2api" ) +const bastionSSHPort = 22 + // ClusterScope holds the per-reconcile state for a StackitCluster. type ClusterScope struct { - Client client.Client Cluster *clusterv1.Cluster StackitCluster *infrav1.StackitCluster + cloudClient cloud.Client + + network *network.Network + networkCreated bool + + loadBalancerTargets []loadbalancer.Target + loadBalancerSeedTargets []loadbalancer.Target + loadBalancerCreated bool + + bastionCloudInit []byte + bastionCloudInitHash string + bastionServerState string + bastionServerPowerStatus string + bastionServerCreated bool patchHelper *patch.Helper } @@ -48,7 +79,6 @@ func NewClusterScope( return nil, err } return &ClusterScope{ - Client: k8sClient, Cluster: cluster, StackitCluster: stackitCluster, patchHelper: patchHelper, @@ -67,7 +97,37 @@ func (s *ClusterScope) PatchObject(ctx context.Context) error { } func (s *ClusterScope) SetConditions(status metav1.ConditionStatus, reason, message string, conditionTypes ...string) { - util.SetConditions(&s.StackitCluster.Status.Conditions, s.StackitCluster.Generation, status, reason, message, conditionTypes...) + setConditions(&s.StackitCluster.Status.Conditions, s.StackitCluster.Generation, status, reason, message, conditionTypes...) +} + +func (s *ClusterScope) SetPausedCondition(paused bool, message string) { + setPausedCondition(&s.StackitCluster.Status.Conditions, s.StackitCluster.Generation, paused, message) +} + +func setConditions( + conditions *[]metav1.Condition, + generation int64, + status metav1.ConditionStatus, + reason, message string, + conditionTypes ...string, +) { + for _, conditionType := range conditionTypes { + meta.SetStatusCondition(conditions, metav1.Condition{ + Type: conditionType, + Status: status, + Reason: reason, + Message: message, + ObservedGeneration: generation, + }) + } +} + +func setPausedCondition(conditions *[]metav1.Condition, generation int64, paused bool, message string) { + if paused { + setConditions(conditions, generation, metav1.ConditionTrue, clusterv1.PausedReason, message, clusterv1.PausedCondition) + return + } + setConditions(conditions, generation, metav1.ConditionFalse, clusterv1.NotPausedReason, "", clusterv1.PausedCondition) } func (s *ClusterScope) SetReady() { @@ -81,29 +141,434 @@ func (s *ClusterScope) SetNotReady(reason, message string, conditionTypes ...str s.SetConditions(metav1.ConditionFalse, reason, message, conditionTypes...) } -func (s *ClusterScope) SetAPIServerEndpoint(endpoint clusterv1.APIEndpoint) { +// CredentialFailureResult records the failure and decides how to retry. +// +// Invalid credentials need an operator to fix the Secret, so they requeue on a +// slow timer rather than returning an error and spinning through the controller +// backoff. The reconcile reads the Secret again, which is what picks up the fix. +func (s *ClusterScope) CredentialFailureResult( + err error, + requeueAfter time.Duration, + conditionTypes ...string, +) (ctrl.Result, error) { + s.SetNotReady("CredentialsInvalid", err.Error(), conditionTypes...) + return credentialFailureResult(err, requeueAfter) +} + +func (s *ClusterScope) CloudFailureResult( + reason string, + err error, + requeueAfter time.Duration, + returnError bool, + conditionTypes ...string, +) (ctrl.Result, error) { + s.SetNotReady(reason, err.Error(), conditionTypes...) + return cloudFailureResult(err, requeueAfter, returnError) +} + +func credentialFailureResult(err error, requeueAfter time.Duration) (ctrl.Result, error) { + if shared.IsUnauthorized(err) || shared.IsInvalidInput(err) || errors.Is(err, util.ErrCredentialsInvalid) { + return ctrl.Result{RequeueAfter: requeueAfter}, nil + } + return ctrl.Result{}, err +} + +func cloudFailureResult(err error, requeueAfter time.Duration, returnError bool) (ctrl.Result, error) { + if shared.IsRetryable(err) { + return ctrl.Result{RequeueAfter: requeueAfter}, nil + } + if returnError { + return ctrl.Result{}, err + } + return ctrl.Result{}, nil +} + +func (s *ClusterScope) setAPIServerEndpoint(endpoint clusterv1.APIEndpoint) { s.StackitCluster.Spec.ControlPlaneEndpoint = endpoint s.StackitCluster.Status.APIServerEndpoint = endpoint } -func (s *ClusterScope) SetBastionStatus(bastion *cloud.Bastion, cloudInitHash string) { - s.StackitCluster.Status.Bastion = infrav1.StackitBastionStatus{ - ServerID: bastion.ServerID, - PublicIPID: bastion.PublicIPID, - PublicIP: bastion.PublicIP, - SecurityGroupID: bastion.SecurityGroupID, - CloudInitHash: cloudInitHash, +func (s *ClusterScope) SetBastionCloudInit(cloudInit []byte, cloudInitHash string) { + s.bastionCloudInit = cloudInit + s.bastionCloudInitHash = cloudInitHash +} + +func (s *ClusterScope) BastionServerState() (state, powerStatus string) { + return s.bastionServerState, s.bastionServerPowerStatus +} + +func (s *ClusterScope) BastionServerCreated() bool { + return s.bastionServerCreated +} + +func (s *ClusterScope) setBastionServer(srv *server.Server, created bool) { + if srv == nil { + s.bastionServerCreated = false + s.bastionServerState = "" + s.bastionServerPowerStatus = "" + s.StackitCluster.Status.Bastion.ServerID = "" + s.StackitCluster.Status.Bastion.CloudInitHash = "" + return + } + s.bastionServerCreated = created + s.bastionServerState = srv.State + s.bastionServerPowerStatus = srv.PowerStatus + s.StackitCluster.Status.Bastion.ServerID = srv.ID + if created { + s.StackitCluster.Status.Bastion.CloudInitHash = s.bastionCloudInitHash } } -func (s *ClusterScope) ClearBastionStatus() { - s.StackitCluster.Status.Bastion = infrav1.StackitBastionStatus{} +func (s *ClusterScope) ServerSpec() server.ServerSpec { + return server.ServerSpec{ + ID: s.StackitCluster.Status.Bastion.ServerID, + Name: s.StackitCluster.Name + "-bastion", + ImageID: s.StackitCluster.Spec.Bastion.ImageID, + MachineType: s.StackitCluster.Spec.Bastion.MachineType, + AvailabilityZone: defaultAvailabilityZone(s.StackitCluster), + SSHKeyName: s.StackitCluster.Spec.Bastion.SSHKeyName, + RequireSSHKey: true, + NetworkID: s.NetworkID(), + UserData: s.bastionCloudInit, + Tags: s.bastionTags(), + RootVolume: rootVolumeFromSpec(s.StackitCluster.Spec.Bastion.RootVolume), + SetServer: s.setBastionServer, + } +} + +func rootVolumeFromSpec(in infrav1.StackitRootVolumeSpec) server.RootVolume { + deleteOnTermination := true + if in.DeleteOnTermination != nil { + deleteOnTermination = *in.DeleteOnTermination + } + return server.RootVolume{ + SizeGiB: in.SizeGiB, + PerformanceClass: in.PerformanceClass, + DeleteOnTermination: deleteOnTermination, + } +} + +func (s *ClusterScope) setBastionSecurityGroup(sg *securitygroup.SecurityGroup) { + if sg == nil { + s.StackitCluster.Status.Bastion.SecurityGroupID = "" + return + } + s.StackitCluster.Status.Bastion.SecurityGroupID = sg.ID +} + +func (s *ClusterScope) HasBastionStatus() bool { + status := s.StackitCluster.Status.Bastion + return status.ServerID != "" || status.PublicIPID != "" || status.PublicIP != "" || status.SecurityGroupID != "" || status.CloudInitHash != "" } func (s *ClusterScope) SetFailureDomains(failureDomains []clusterv1.FailureDomain) { s.StackitCluster.Status.FailureDomains = failureDomains } +// defaultAvailabilityZone returns the default single availability zone for a +// StackitCluster (the alphabetically first published failure domain, falling +// back to -1). This prevents the STACKIT IaaS API from defaulting to +// the expensive metro zone (-m). +func defaultAvailabilityZone(stackitCluster *infrav1.StackitCluster) string { + if stackitCluster == nil { + return "" + } + if len(stackitCluster.Status.FailureDomains) > 0 { + zones := make([]string, 0, len(stackitCluster.Status.FailureDomains)) + for _, fd := range stackitCluster.Status.FailureDomains { + zones = append(zones, fd.Name) + } + slices.Sort(zones) + return zones[0] + } + if stackitCluster.Spec.Region != "" { + return stackitCluster.Spec.Region + "-1" + } + return "" +} + +func (s *ClusterScope) SetCloudClient(cloudClient cloud.Client) { + s.cloudClient = cloudClient +} + +func (s *ClusterScope) ProjectID() string { + if s.StackitCluster.Spec.ProjectID != "" { + return s.StackitCluster.Spec.ProjectID + } + return s.cloudClient.ProjectID() +} + +func (s *ClusterScope) Region() string { + if s.StackitCluster.Spec.Region != "" { + return s.StackitCluster.Spec.Region + } + return s.cloudClient.Region() +} + +func (s *ClusterScope) IaaSClient() *iaas.APIClient { + return s.cloudClient.IaaSClient() +} + +func (s *ClusterScope) LoadBalancerClient() *lb.APIClient { + return s.cloudClient.LoadBalancerClient() +} + +func (s *ClusterScope) apiServerLoadBalancerTags() map[string]string { + return util.ClusterTags(s.StackitCluster.Name, s.StackitCluster.Namespace, s.StackitCluster.Spec.AdditionalLabels) +} + +func (s *ClusterScope) APIServerLoadBalancerCreated() bool { + return s.loadBalancerCreated +} + +func (s *ClusterScope) setAPIServerLoadBalancer(apiServerLB *loadbalancer.LoadBalancer, created bool) { + if apiServerLB == nil { + s.loadBalancerCreated = false + s.StackitCluster.Status.APIServerLoadBalancerID = "" + s.StackitCluster.Status.APIServerEndpoint = clusterv1.APIEndpoint{} + return + } + s.loadBalancerCreated = created + s.StackitCluster.Status.APIServerLoadBalancerID = apiServerLB.ID + if apiServerLB.IP == "" { + s.StackitCluster.Status.APIServerEndpoint = clusterv1.APIEndpoint{} + return + } + s.setAPIServerEndpoint(clusterv1.APIEndpoint{ + Host: apiServerLB.IP, + Port: apiServerLB.Port, + }) +} + +func (s *ClusterScope) SetAPIServerLoadBalancerTargets(targets, seedTargets []loadbalancer.Target) { + s.loadBalancerTargets = targets + s.loadBalancerSeedTargets = seedTargets +} + +func (s *ClusterScope) LoadBalancerSpec() loadbalancer.LoadBalancerSpec { + return loadbalancer.LoadBalancerSpec{ + ID: s.StackitCluster.Status.APIServerLoadBalancerID, + Name: s.StackitCluster.Name + "-apiserver", + NetworkID: s.NetworkID(), + Port: loadbalancer.DefaultAPIServerPort, + Tags: s.apiServerLoadBalancerTags(), + Targets: s.loadBalancerTargets, + SeedTargets: s.loadBalancerSeedTargets, + SetLoadBalancer: s.setAPIServerLoadBalancer, + } +} + +func (s *ClusterScope) AvailabilityZoneSpec() availabilityzone.AvailabilityZoneSpec { + return availabilityzone.AvailabilityZoneSpec{ + SetZones: func(zones []string) { + s.SetFailureDomains(failureDomainsFromZones(s.Region(), zones)) + }, + } +} + +func (s *ClusterScope) NetworkCreated() bool { + return s.networkCreated +} + +func (s *ClusterScope) setNetwork(net *network.Network, created bool) { + if net == nil { + s.network = nil + s.networkCreated = false + s.StackitCluster.Status.Network = infrav1.StackitNetworkStatus{} + return + } + s.network = net + s.networkCreated = created + s.StackitCluster.Status.Network = infrav1.StackitNetworkStatus{ + ID: net.ID, + Managed: s.StackitCluster.Spec.Network.ID == "", + } +} + +func (s *ClusterScope) NetworkSpec() network.NetworkSpec { + if s.StackitCluster.Spec.Network.ID != "" { + return network.NetworkSpec{ + ID: s.StackitCluster.Spec.Network.ID, + SetNetwork: s.setNetwork, + } + } + return network.NetworkSpec{ + ID: s.StackitCluster.Status.Network.ID, + Name: s.StackitCluster.Name + "-network", + IPv4Prefix: network.DefaultNetworkPrefix, + Tags: util.ClusterTags(s.StackitCluster.Name, s.StackitCluster.Namespace, s.StackitCluster.Spec.AdditionalLabels), + Managed: true, + SetNetwork: s.setNetwork, + } +} + +func (s *ClusterScope) BootstrapTargetIP() string { + if s.network == nil { + return loadbalancer.DefaultBootstrapTargetIP + } + for _, prefixValue := range s.network.IPv4Prefixes { + prefix, err := netip.ParsePrefix(prefixValue) + if err != nil || !prefix.Addr().Is4() { + continue + } + address := prefix.Masked().Addr() + for range 10 { + address = address.Next() + } + if prefix.Contains(address) { + return address.String() + } + } + return loadbalancer.DefaultBootstrapTargetIP +} + +func (s *ClusterScope) PublicIPSpec() publicip.PublicIPSpec { + return publicip.PublicIPSpec{ + ID: s.StackitCluster.Status.Bastion.PublicIPID, + Tags: s.bastionTags(), + ServerID: s.StackitCluster.Status.Bastion.ServerID, + ServerSelector: s.bastionTags(), + SetPublicIP: s.setBastionPublicIP, + } +} + +func (s *ClusterScope) bastionTags() map[string]string { + return bastionTags(s.StackitCluster) +} + +func DefaultFailureDomains(region string) []clusterv1.FailureDomain { + controlPlane := true + return []clusterv1.FailureDomain{ + { + Name: region + "-1", + ControlPlane: &controlPlane, + Attributes: map[string]string{ + "region": region, + }, + }, + { + Name: region + "-2", + ControlPlane: &controlPlane, + Attributes: map[string]string{ + "region": region, + }, + }, + { + Name: region + "-3", + ControlPlane: &controlPlane, + Attributes: map[string]string{ + "region": region, + }, + }, + } +} + +func failureDomainsFromZones(region string, zones []string) []clusterv1.FailureDomain { + controlPlane := true + failureDomains := make([]clusterv1.FailureDomain, 0, len(zones)) + for _, zone := range zones { + // Filter out virtual/metro zones (such as eu01-m or any zone with suffix -m) + if strings.HasSuffix(zone, "-m") { + continue + } + failureDomains = append(failureDomains, clusterv1.FailureDomain{ + Name: zone, + ControlPlane: &controlPlane, + Attributes: map[string]string{ + "region": region, + }, + }) + } + if len(failureDomains) == 0 { + return DefaultFailureDomains(region) + } + slices.SortFunc(failureDomains, func(a, b clusterv1.FailureDomain) int { + return strings.Compare(a.Name, b.Name) + }) + return failureDomains +} + +func bastionTags(stackitCluster *infrav1.StackitCluster) map[string]string { + tags := util.ClusterTags(stackitCluster.Name, stackitCluster.Namespace, stackitCluster.Spec.AdditionalLabels) + tags[util.LabelResourceRole] = util.ResourceRoleBastion + return tags +} + +func NodeSSHTags(stackitCluster *infrav1.StackitCluster) map[string]string { + tags := util.ClusterTags(stackitCluster.Name, stackitCluster.Namespace, stackitCluster.Spec.AdditionalLabels) + tags[util.LabelResourceRole] = util.ResourceRoleNodeSSH + return tags +} + +func (s *ClusterScope) setBastionPublicIP(pip *publicip.PublicIP) { + if pip == nil { + s.StackitCluster.Status.Bastion.PublicIPID = "" + s.StackitCluster.Status.Bastion.PublicIP = "" + return + } + s.StackitCluster.Status.Bastion.PublicIPID = pip.ID + s.StackitCluster.Status.Bastion.PublicIP = pip.IP +} + +func (s *ClusterScope) SecurityGroupSpecs() []securitygroup.SecurityGroupSpec { + allowedCIDRs := s.StackitCluster.Spec.Bastion.AllowedCIDRs + if len(allowedCIDRs) == 0 { + allowedCIDRs = []string{""} + } + rules := make([]securitygroup.Rule, 0, len(allowedCIDRs)+1) + for _, cidr := range allowedCIDRs { + rules = append(rules, securitygroup.Rule{ + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: bastionSSHPort, + PortMax: bastionSSHPort, + IPRange: cidr, + }) + } + rules = append(rules, securitygroup.Rule{ + Direction: securitygroup.DirectionEgress, + }) + return []securitygroup.SecurityGroupSpec{ + { + ID: s.StackitCluster.Status.Bastion.SecurityGroupID, + Name: s.StackitCluster.Name + "-bastion-ssh", + Description: "Cluster API Provider STACKIT bastion SSH access", + Tags: s.bastionTags(), + Rules: rules, + ServerIDs: []string{s.StackitCluster.Status.Bastion.ServerID}, + ServerSelector: s.bastionTags(), + SetSecurityGroup: s.setBastionSecurityGroup, + }, + nodeSSHSecurityGroupSpec(s.StackitCluster, ""), + } +} + +func nodeSSHSecurityGroupSpec(stackitCluster *infrav1.StackitCluster, remoteSecurityGroupID string, serverIDs ...string) securitygroup.SecurityGroupSpec { + ingressRule := securitygroup.Rule{ + Direction: securitygroup.DirectionIngress, + Protocol: securitygroup.ProtocolTCP, + PortMin: bastionSSHPort, + PortMax: bastionSSHPort, + RemoteSecurityGroupID: remoteSecurityGroupID, + } + if remoteSecurityGroupID == "" { + ingressRule.RemoteSecurityGroupTags = bastionTags(stackitCluster) + } + return securitygroup.SecurityGroupSpec{ + Name: stackitCluster.Name + "-node-ssh", + Description: "Cluster API Provider STACKIT node SSH access from bastion", + Tags: NodeSSHTags(stackitCluster), + ServerIDs: serverIDs, + ServerSelector: util.ClusterTags(stackitCluster.Name, stackitCluster.Namespace, stackitCluster.Spec.AdditionalLabels), + Rules: []securitygroup.Rule{ + ingressRule, + { + Direction: securitygroup.DirectionEgress, + }, + }, + } +} + // NetworkID returns the cluster network ID (from spec if BYO, or status if managed). func (s *ClusterScope) NetworkID() string { if s.StackitCluster == nil { diff --git a/scope/cluster_scope_test.go b/scope/cluster_scope_test.go new file mode 100644 index 0000000..d9ea68d --- /dev/null +++ b/scope/cluster_scope_test.go @@ -0,0 +1,636 @@ +/* +Copyright 2026. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 +*/ + +package scope + +import ( + "errors" + "fmt" + "reflect" + "testing" + "time" + + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" + ctrl "sigs.k8s.io/controller-runtime" + + infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" + cloudfake "github.com/stackitcloud/cluster-api-provider-stackit/cloud/fake" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/loadbalancer" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/network" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/publicip" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/shared" + "github.com/stackitcloud/cluster-api-provider-stackit/util" +) + +func TestDefaultAvailabilityZone(t *testing.T) { + tests := []struct { + name string + region string + failureDomains []clusterv1.FailureDomain + wantAZ string + }{ + { + name: "selects first failure domain sorted alphabetically", + region: "eu01", + failureDomains: []clusterv1.FailureDomain{ + {Name: "eu01-3"}, + {Name: "eu01-2"}, + {Name: "eu01-1"}, + }, + wantAZ: "eu01-1", + }, + { + name: "falls back to region-1 when failureDomains is empty", + region: "eu02", + failureDomains: nil, + wantAZ: "eu02-1", + }, + { + name: "returns empty when region and failureDomains are empty", + region: "", + failureDomains: nil, + wantAZ: "", + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + cluster := &infrav1.StackitCluster{ + Spec: infrav1.StackitClusterSpec{ + Region: test.region, + }, + Status: infrav1.StackitClusterStatus{ + FailureDomains: test.failureDomains, + }, + } + clusterScope := &ClusterScope{StackitCluster: cluster} + if got := clusterScope.ServerSpec().AvailabilityZone; got != test.wantAZ { + t.Fatalf("ServerSpec().AvailabilityZone = %q, want %q", got, test.wantAZ) + } + }) + } +} + +func TestAvailabilityZoneSpecUsesResolvedRegion(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{}, + cloudClient: cloudfake.New(), + } + + clusterScope.AvailabilityZoneSpec().SetZones([]string{"eu01-1"}) + + if len(clusterScope.StackitCluster.Status.FailureDomains) != 1 { + t.Fatalf("FailureDomains = %#v, want 1 entry", clusterScope.StackitCluster.Status.FailureDomains) + } + gotRegion := clusterScope.StackitCluster.Status.FailureDomains[0].Attributes["region"] + if gotRegion != "eu01" { + t.Fatalf("FailureDomains[0].Attributes[region] = %q, want %q", gotRegion, "eu01") + } +} + +func TestServerSpecSetServerPreservesCloudInitHashOnAdoptedServer(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{}, + } + clusterScope.SetBastionCloudInit([]byte("#cloud-config\npackages:\n- jq\n"), "new-hash") + + spec := clusterScope.ServerSpec() + spec.SetServer(&server.Server{ID: "srv-adopted", State: "ACTIVE", PowerStatus: "RUNNING"}, false) + + if clusterScope.BastionServerCreated() { + t.Fatal("BastionServerCreated() = true on adopted server, want false") + } + if got := clusterScope.StackitCluster.Status.Bastion.CloudInitHash; got != "" { + t.Fatalf("Status.Bastion.CloudInitHash on adopted server = %q, want empty", got) + } + + spec.SetServer(&server.Server{ID: "srv-created", State: "ACTIVE", PowerStatus: "RUNNING"}, true) + if !clusterScope.BastionServerCreated() { + t.Fatal("BastionServerCreated() = false on created server, want true") + } + if got := clusterScope.StackitCluster.Status.Bastion.CloudInitHash; got != "new-hash" { + t.Fatalf("Status.Bastion.CloudInitHash on created server = %q, want %q", got, "new-hash") + } + + spec.SetServer(nil, false) + if clusterScope.BastionServerCreated() { + t.Fatal("BastionServerCreated() = true after SetServer(nil, false), want false") + } + if state, powerStatus := clusterScope.BastionServerState(); state != "" || powerStatus != "" { + t.Fatalf("BastionServerState() after SetServer(nil, false) = (%q, %q), want empty", state, powerStatus) + } + if got := clusterScope.StackitCluster.Status.Bastion.ServerID; got != "" { + t.Fatalf("Status.Bastion.ServerID after SetServer(nil, false) = %q, want empty", got) + } + if got := clusterScope.StackitCluster.Status.Bastion.CloudInitHash; got != "" { + t.Fatalf("Status.Bastion.CloudInitHash after SetServer(nil, false) = %q, want empty", got) + } +} + +func TestLoadBalancerSpecSetLoadBalancerClearsOnNil(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{}, + } + + spec := clusterScope.LoadBalancerSpec() + spec.SetLoadBalancer(&loadbalancer.LoadBalancer{ + ID: "lb-1", + IP: "203.0.113.10", + Port: 6443, + }, true) + + if !clusterScope.APIServerLoadBalancerCreated() { + t.Fatal("APIServerLoadBalancerCreated() = false on created load balancer, want true") + } + if clusterScope.StackitCluster.Status.APIServerLoadBalancerID != "lb-1" { + t.Fatalf("Status.APIServerLoadBalancerID = %q, want lb-1", clusterScope.StackitCluster.Status.APIServerLoadBalancerID) + } + wantEndpoint := clusterv1.APIEndpoint{Host: "203.0.113.10", Port: 6443} + if clusterScope.StackitCluster.Spec.ControlPlaneEndpoint != wantEndpoint { + t.Fatalf("Spec.ControlPlaneEndpoint = %#v, want %#v", clusterScope.StackitCluster.Spec.ControlPlaneEndpoint, wantEndpoint) + } + if clusterScope.StackitCluster.Status.APIServerEndpoint != wantEndpoint { + t.Fatalf("Status.APIServerEndpoint = %#v, want %#v", clusterScope.StackitCluster.Status.APIServerEndpoint, wantEndpoint) + } + + spec.SetLoadBalancer(nil, false) + if clusterScope.APIServerLoadBalancerCreated() { + t.Fatal("APIServerLoadBalancerCreated() = true after SetLoadBalancer(nil, false), want false") + } + if clusterScope.StackitCluster.Status.APIServerLoadBalancerID != "" { + t.Fatalf("Status.APIServerLoadBalancerID after clear = %q, want empty", clusterScope.StackitCluster.Status.APIServerLoadBalancerID) + } + if clusterScope.StackitCluster.Status.APIServerEndpoint != (clusterv1.APIEndpoint{}) { + t.Fatalf("Status.APIServerEndpoint after clear = %#v, want empty", clusterScope.StackitCluster.Status.APIServerEndpoint) + } + if clusterScope.StackitCluster.Spec.ControlPlaneEndpoint != wantEndpoint { + t.Fatalf("Spec.ControlPlaneEndpoint after clear = %#v, want preserved %#v", clusterScope.StackitCluster.Spec.ControlPlaneEndpoint, wantEndpoint) + } +} + +func TestPublicIPSpecSetPublicIPClearsOnNil(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{}, + } + + spec := clusterScope.PublicIPSpec() + spec.SetPublicIP(&publicip.PublicIP{ + ID: "pip-1", + IP: "203.0.113.22", + }) + + if clusterScope.StackitCluster.Status.Bastion.PublicIPID != "pip-1" { + t.Fatalf("Status.Bastion.PublicIPID = %q, want pip-1", clusterScope.StackitCluster.Status.Bastion.PublicIPID) + } + if clusterScope.StackitCluster.Status.Bastion.PublicIP != "203.0.113.22" { + t.Fatalf("Status.Bastion.PublicIP = %q, want 203.0.113.22", clusterScope.StackitCluster.Status.Bastion.PublicIP) + } + + spec.SetPublicIP(nil) + if clusterScope.StackitCluster.Status.Bastion.PublicIPID != "" { + t.Fatalf("Status.Bastion.PublicIPID after clear = %q, want empty", clusterScope.StackitCluster.Status.Bastion.PublicIPID) + } + if clusterScope.StackitCluster.Status.Bastion.PublicIP != "" { + t.Fatalf("Status.Bastion.PublicIP after clear = %q, want empty", clusterScope.StackitCluster.Status.Bastion.PublicIP) + } +} + +func TestSecurityGroupSpecsSetSecurityGroupClearsOnNil(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{}, + } + + specs := clusterScope.SecurityGroupSpecs() + if len(specs) != 2 { + t.Fatalf("SecurityGroupSpecs() count = %d, want 2", len(specs)) + } + + specs[0].SetSecurityGroup(&securitygroup.SecurityGroup{ + ID: "sg-1", + Name: "bastion-ssh", + }) + if clusterScope.StackitCluster.Status.Bastion.SecurityGroupID != "sg-1" { + t.Fatalf("Status.Bastion.SecurityGroupID = %q, want sg-1", clusterScope.StackitCluster.Status.Bastion.SecurityGroupID) + } + + specs[0].SetSecurityGroup(nil) + if clusterScope.StackitCluster.Status.Bastion.SecurityGroupID != "" { + t.Fatalf("Status.Bastion.SecurityGroupID after clear = %q, want empty", clusterScope.StackitCluster.Status.Bastion.SecurityGroupID) + } +} + +func TestMachineScopeServerSpecSetServerClearsOnNil(t *testing.T) { + machineScope := &MachineScope{ + cluster: &clusterv1.Cluster{}, + Machine: &clusterv1.Machine{}, + StackitCluster: &infrav1.StackitCluster{}, + StackitMachine: &infrav1.StackitMachine{}, + } + + spec := machineScope.ServerSpec() + spec.SetServer(&server.Server{ + ID: "srv-1", + State: "ACTIVE", + PowerStatus: "RUNNING", + AvailabilityZone: "eu01-1", + Addresses: []server.Address{{Type: "InternalIP", Address: "10.0.0.5"}}, + }, true) + + if !machineScope.InstanceCreated() || machineScope.InstancePowerStatus() != "RUNNING" { + t.Fatalf("InstanceCreated=%v, InstancePowerStatus=%q", machineScope.InstanceCreated(), machineScope.InstancePowerStatus()) + } + if machineScope.StackitMachine.Status.InstanceID != "srv-1" { + t.Fatalf("Status.InstanceID = %q, want srv-1", machineScope.StackitMachine.Status.InstanceID) + } + + spec.SetServer(nil, false) + if machineScope.InstanceCreated() || machineScope.InstancePowerStatus() != "" { + t.Fatalf("after SetServer(nil, false): InstanceCreated=%v, InstancePowerStatus=%q, want false and empty", machineScope.InstanceCreated(), machineScope.InstancePowerStatus()) + } + if machineScope.StackitMachine.Status.InstanceID != "" || + machineScope.StackitMachine.Status.InstanceState != "" || + machineScope.StackitMachine.Status.AvailabilityZone != "" || + len(machineScope.StackitMachine.Status.Addresses) != 0 { + t.Fatalf("Status after SetServer(nil, false) = %#v, want cleared instance fields", machineScope.StackitMachine.Status) + } +} + +func TestNodeSSHSecurityGroupSpecIncludesAdditionalLabelsInServerSelector(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{ + Name: "my-cluster", + Namespace: "my-ns", + }, + Spec: infrav1.StackitClusterSpec{ + AdditionalLabels: map[string]string{ + "env": "staging", + }, + }, + }, + } + + specs := clusterScope.SecurityGroupSpecs() + if len(specs) != 2 { + t.Fatalf("SecurityGroupSpecs() count = %d, want 2", len(specs)) + } + + wantSelector := util.ClusterTags("my-cluster", "my-ns", map[string]string{"env": "staging"}) + if got := specs[1].ServerSelector; !reflect.DeepEqual(got, wantSelector) { + t.Fatalf("nodeSSHSecurityGroupSpec ServerSelector = %#v, want %#v", got, wantSelector) + } +} + +func TestClusterScopeSecurityGroupSpecsIncludesEmptyIngressRuleWhenAllowedCIDRsMissing(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{ + Name: "my-cluster", + Namespace: "my-ns", + }, + }, + } + + specs := clusterScope.SecurityGroupSpecs() + if len(specs) != 2 { + t.Fatalf("SecurityGroupSpecs() count = %d, want 2", len(specs)) + } + if len(specs[0].Rules) != 2 { + t.Fatalf("bastion SecurityGroupSpec Rules count = %d, want 2 (1 ingress + 1 egress)", len(specs[0].Rules)) + } + if specs[0].Rules[0].Direction != securitygroup.DirectionIngress || specs[0].Rules[0].IPRange != "" { + t.Fatalf("bastion SecurityGroupSpec Rules[0] = %#v, want ingress rule with empty IPRange", specs[0].Rules[0]) + } +} + +func TestServerSpecRequireSSHKey(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + Spec: infrav1.StackitClusterSpec{ + Bastion: infrav1.StackitBastionSpec{ + SSHKeyName: "my-key", + }, + }, + }, + } + clusterServerSpec := clusterScope.ServerSpec() + if !clusterServerSpec.RequireSSHKey { + t.Fatal("ClusterScope.ServerSpec().RequireSSHKey = false, want true") + } + if clusterServerSpec.SSHKeyName != "my-key" { + t.Fatalf("ClusterScope.ServerSpec().SSHKeyName = %q, want %q", clusterServerSpec.SSHKeyName, "my-key") + } + + machineScope := &MachineScope{ + cluster: &clusterv1.Cluster{}, + Machine: &clusterv1.Machine{}, + StackitCluster: &infrav1.StackitCluster{}, + StackitMachine: &infrav1.StackitMachine{}, + } + if machineScope.ServerSpec().RequireSSHKey { + t.Fatal("MachineScope.ServerSpec().RequireSSHKey = true, want false") + } +} + +func TestMachineScopeSecurityGroupSpecsRespectsBastionEnabled(t *testing.T) { + machineScope := &MachineScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{ + Name: "my-cluster", + Namespace: "my-ns", + }, + Spec: infrav1.StackitClusterSpec{ + Bastion: infrav1.StackitBastionSpec{ + Enabled: false, + }, + }, + Status: infrav1.StackitClusterStatus{ + Bastion: infrav1.StackitBastionStatus{ + SecurityGroupID: "bastion-sg-id", + }, + }, + }, + StackitMachine: &infrav1.StackitMachine{ + Status: infrav1.StackitMachineStatus{ + InstanceID: "srv-1", + }, + }, + } + + if got := machineScope.SecurityGroupSpecs(); len(got) != 0 { + t.Fatalf("SecurityGroupSpecs() when bastion disabled = %#v, want empty", got) + } + + machineScope.StackitCluster.Spec.Bastion.Enabled = true + got := machineScope.SecurityGroupSpecs() + if len(got) != 1 { + t.Fatalf("SecurityGroupSpecs() when bastion enabled count = %d, want 1", len(got)) + } + if !reflect.DeepEqual(got[0].ServerIDs, []string{"srv-1"}) { + t.Fatalf("SecurityGroupSpecs()[0].ServerIDs = %#v, want [srv-1]", got[0].ServerIDs) + } + if len(got[0].Rules) == 0 || got[0].Rules[0].RemoteSecurityGroupID != "bastion-sg-id" { + t.Fatalf("SecurityGroupSpecs()[0].Rules = %#v, want RemoteSecurityGroupID=bastion-sg-id", got[0].Rules) + } +} + +func TestBootstrapTargetIP(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{}, + } + if got := clusterScope.BootstrapTargetIP(); got != loadbalancer.DefaultBootstrapTargetIP { + t.Fatalf("BootstrapTargetIP() with nil network = %q, want %q", got, loadbalancer.DefaultBootstrapTargetIP) + } + + clusterScope.NetworkSpec().SetNetwork(&network.Network{ + ID: "net-1", + IPv4Prefixes: []string{"192.168.10.0/24"}, + }, false) + if got := clusterScope.BootstrapTargetIP(); got != "192.168.10.10" { + t.Fatalf("BootstrapTargetIP() with /24 network = %q, want %q", got, "192.168.10.10") + } + + clusterScope.NetworkSpec().SetNetwork(&network.Network{ + ID: "net-2", + IPv4Prefixes: []string{"invalid"}, + }, false) + if got := clusterScope.BootstrapTargetIP(); got != loadbalancer.DefaultBootstrapTargetIP { + t.Fatalf("BootstrapTargetIP() with invalid prefix = %q, want %q", got, loadbalancer.DefaultBootstrapTargetIP) + } +} + +func TestHasBastionStatus(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{}, + } + if clusterScope.HasBastionStatus() { + t.Fatal("HasBastionStatus() = true on empty status, want false") + } + + clusterScope.StackitCluster.Status.Bastion.ServerID = "srv-1" + if !clusterScope.HasBastionStatus() { + t.Fatal("HasBastionStatus() = false when ServerID is set, want true") + } +} + +func TestClusterScopeCredentialFailureResult(t *testing.T) { + requeueAfter := time.Minute + + t.Run("requeues on invalid credentials and marks cluster not ready", func(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{Generation: 3}, + Status: infrav1.StackitClusterStatus{Ready: true}, + }, + } + err := fmt.Errorf("auth failed: %w", shared.ErrUnauthorized) + + result, gotErr := clusterScope.CredentialFailureResult( + err, + requeueAfter, + infrav1.ClusterCredentialsReadyCondition, + infrav1.ClusterReadyCondition, + ) + if gotErr != nil { + t.Fatalf("CredentialFailureResult() error = %v, want nil", gotErr) + } + if result != (ctrl.Result{RequeueAfter: requeueAfter}) { + t.Fatalf("CredentialFailureResult() result = %#v, want RequeueAfter=%v", result, requeueAfter) + } + if clusterScope.StackitCluster.Status.Ready { + t.Fatal("StackitCluster.Status.Ready = true, want false") + } + assertConditionFalse(t, clusterScope.StackitCluster.Status.Conditions, infrav1.ClusterCredentialsReadyCondition, "CredentialsInvalid", err.Error(), 3) + assertConditionFalse(t, clusterScope.StackitCluster.Status.Conditions, infrav1.ClusterReadyCondition, "CredentialsInvalid", err.Error(), 3) + }) + + t.Run("returns error on non-credential error", func(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{Generation: 2}, + }, + } + err := errors.New("k8s api error") + + result, gotErr := clusterScope.CredentialFailureResult(err, requeueAfter, infrav1.ClusterCredentialsReadyCondition) + if !errors.Is(gotErr, err) { + t.Fatalf("CredentialFailureResult() error = %v, want %v", gotErr, err) + } + if result != (ctrl.Result{}) { + t.Fatalf("CredentialFailureResult() result = %#v, want empty", result) + } + }) +} + +func TestClusterScopeCloudFailureResult(t *testing.T) { + requeueAfter := 5 * time.Second + + t.Run("requeues on retryable error and marks cluster not ready", func(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{Generation: 4}, + Status: infrav1.StackitClusterStatus{Ready: true}, + }, + } + err := fmt.Errorf("temporary failure: %w", shared.ErrTransient) + + result, gotErr := clusterScope.CloudFailureResult( + "NetworkNotFound", + err, + requeueAfter, + false, + infrav1.ClusterNetworkReadyCondition, + infrav1.ClusterReadyCondition, + ) + if gotErr != nil { + t.Fatalf("CloudFailureResult() error = %v, want nil", gotErr) + } + if result != (ctrl.Result{RequeueAfter: requeueAfter}) { + t.Fatalf("CloudFailureResult() result = %#v, want RequeueAfter=%v", result, requeueAfter) + } + if clusterScope.StackitCluster.Status.Ready { + t.Fatal("StackitCluster.Status.Ready = true, want false") + } + assertConditionFalse(t, clusterScope.StackitCluster.Status.Conditions, infrav1.ClusterNetworkReadyCondition, "NetworkNotFound", err.Error(), 4) + assertConditionFalse(t, clusterScope.StackitCluster.Status.Conditions, infrav1.ClusterReadyCondition, "NetworkNotFound", err.Error(), 4) + }) + + t.Run("returns nil on non-retryable error when returnError is false", func(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{Generation: 1}, + }, + } + err := fmt.Errorf("not found: %w", shared.ErrNotFound) + + result, gotErr := clusterScope.CloudFailureResult("NetworkNotFound", err, requeueAfter, false, infrav1.ClusterReadyCondition) + if gotErr != nil { + t.Fatalf("CloudFailureResult() error = %v, want nil", gotErr) + } + if result != (ctrl.Result{}) { + t.Fatalf("CloudFailureResult() result = %#v, want empty", result) + } + }) + + t.Run("returns error on non-retryable error when returnError is true", func(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{Generation: 1}, + }, + } + err := fmt.Errorf("invalid input: %w", shared.ErrInvalidInput) + + result, gotErr := clusterScope.CloudFailureResult("AvailabilityZonesError", err, requeueAfter, true, infrav1.ClusterReadyCondition) + if !errors.Is(gotErr, err) { + t.Fatalf("CloudFailureResult() error = %v, want %v", gotErr, err) + } + if result != (ctrl.Result{}) { + t.Fatalf("CloudFailureResult() result = %#v, want empty", result) + } + }) +} + +func TestMachineScopeFailureResults(t *testing.T) { + requeueAfter := 5 * time.Second + + machineScope := &MachineScope{ + StackitMachine: &infrav1.StackitMachine{ + ObjectMeta: metav1.ObjectMeta{Generation: 5}, + Status: infrav1.StackitMachineStatus{Ready: true}, + }, + } + credErr := fmt.Errorf("invalid secret: %w", util.ErrCredentialsInvalid) + result, gotErr := machineScope.CredentialFailureResult( + credErr, + requeueAfter, + infrav1.MachineCredentialsReadyCondition, + ) + if gotErr != nil || result != (ctrl.Result{RequeueAfter: requeueAfter}) { + t.Fatalf("CredentialFailureResult() = (%#v, %v), want (RequeueAfter=%v, nil)", result, gotErr, requeueAfter) + } + if machineScope.StackitMachine.Status.Ready { + t.Fatal("StackitMachine.Status.Ready = true after CredentialFailureResult, want false") + } + assertConditionFalse(t, machineScope.StackitMachine.Status.Conditions, infrav1.MachineCredentialsReadyCondition, "CredentialsInvalid", credErr.Error(), 5) + + machineScope.SetReady() + cloudErr := fmt.Errorf("create server rejected: %w", shared.ErrInvalidInput) + result, gotErr = machineScope.CloudFailureResult( + "InstanceError", + cloudErr, + requeueAfter, + true, + infrav1.MachineInstanceReadyCondition, + infrav1.MachineReadyCondition, + ) + if !errors.Is(gotErr, cloudErr) || result != (ctrl.Result{}) { + t.Fatalf("CloudFailureResult() = (%#v, %v), want (empty, %v)", result, gotErr, cloudErr) + } + if machineScope.StackitMachine.Status.Ready { + t.Fatal("StackitMachine.Status.Ready = true after CloudFailureResult, want false") + } + assertConditionFalse(t, machineScope.StackitMachine.Status.Conditions, infrav1.MachineInstanceReadyCondition, "InstanceError", cloudErr.Error(), 5) + assertConditionFalse(t, machineScope.StackitMachine.Status.Conditions, infrav1.MachineReadyCondition, "InstanceError", cloudErr.Error(), 5) +} + +func TestScopeSetPausedCondition(t *testing.T) { + clusterScope := &ClusterScope{ + StackitCluster: &infrav1.StackitCluster{ + ObjectMeta: metav1.ObjectMeta{Generation: 2}, + }, + } + + clusterScope.SetPausedCondition(true, "Cluster spec.paused is set to true") + assertCondition(t, clusterScope.StackitCluster.Status.Conditions, clusterv1.PausedCondition, metav1.ConditionTrue, clusterv1.PausedReason, "Cluster spec.paused is set to true", 2) + + clusterScope.SetPausedCondition(false, "") + assertCondition(t, clusterScope.StackitCluster.Status.Conditions, clusterv1.PausedCondition, metav1.ConditionFalse, clusterv1.NotPausedReason, "", 2) + + machineScope := &MachineScope{ + StackitMachine: &infrav1.StackitMachine{ + ObjectMeta: metav1.ObjectMeta{Generation: 6}, + }, + } + + machineScope.SetPausedCondition(true, "object has the cluster.x-k8s.io/paused annotation") + assertCondition(t, machineScope.StackitMachine.Status.Conditions, clusterv1.PausedCondition, metav1.ConditionTrue, clusterv1.PausedReason, "object has the cluster.x-k8s.io/paused annotation", 6) + + machineScope.SetPausedCondition(false, "") + assertCondition(t, machineScope.StackitMachine.Status.Conditions, clusterv1.PausedCondition, metav1.ConditionFalse, clusterv1.NotPausedReason, "", 6) +} + +func assertConditionFalse(t *testing.T, conditions []metav1.Condition, condType, wantReason, wantMessage string, wantGeneration int64) { + t.Helper() + assertCondition(t, conditions, condType, metav1.ConditionFalse, wantReason, wantMessage, wantGeneration) +} + +func assertCondition(t *testing.T, conditions []metav1.Condition, condType string, wantStatus metav1.ConditionStatus, wantReason, wantMessage string, wantGeneration int64) { + t.Helper() + cond := meta.FindStatusCondition(conditions, condType) + if cond == nil { + t.Fatalf("condition %q not found", condType) + } + if cond.Status != wantStatus { + t.Fatalf("condition %q status = %q, want %q", condType, cond.Status, wantStatus) + } + if cond.Reason != wantReason { + t.Fatalf("condition %q reason = %q, want %q", condType, cond.Reason, wantReason) + } + if cond.Message != wantMessage { + t.Fatalf("condition %q message = %q, want %q", condType, cond.Message, wantMessage) + } + if cond.ObservedGeneration != wantGeneration { + t.Fatalf("condition %q observedGeneration = %d, want %d", condType, cond.ObservedGeneration, wantGeneration) + } +} diff --git a/scope/machine_scope.go b/scope/machine_scope.go index 8846b9a..652a6e9 100644 --- a/scope/machine_scope.go +++ b/scope/machine_scope.go @@ -12,9 +12,11 @@ package scope import ( "context" - "slices" + "fmt" + "time" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" @@ -22,16 +24,23 @@ import ( infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" "github.com/stackitcloud/cluster-api-provider-stackit/cloud" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/securitygroup" + "github.com/stackitcloud/cluster-api-provider-stackit/cloud/services/server" "github.com/stackitcloud/cluster-api-provider-stackit/util" + iaas "github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api" ) // MachineScope holds the per-reconcile state for a StackitMachine. type MachineScope struct { - Client client.Client - Cluster *clusterv1.Cluster Machine *clusterv1.Machine StackitCluster *infrav1.StackitCluster StackitMachine *infrav1.StackitMachine + cluster *clusterv1.Cluster + cloudClient cloud.Client + + bootstrapData []byte + instancePowerStatus string + instanceCreated bool patchHelper *patch.Helper } @@ -50,11 +59,10 @@ func NewMachineScope( return nil, err } return &MachineScope{ - Client: k8sClient, - Cluster: cluster, Machine: machine, StackitCluster: stackitCluster, StackitMachine: stackitMachine, + cluster: cluster, patchHelper: patchHelper, }, nil } @@ -71,7 +79,11 @@ func (s *MachineScope) PatchObject(ctx context.Context) error { } func (s *MachineScope) SetConditions(status metav1.ConditionStatus, reason, message string, conditionTypes ...string) { - util.SetConditions(&s.StackitMachine.Status.Conditions, s.StackitMachine.Generation, status, reason, message, conditionTypes...) + setConditions(&s.StackitMachine.Status.Conditions, s.StackitMachine.Generation, status, reason, message, conditionTypes...) +} + +func (s *MachineScope) SetPausedCondition(paused bool, message string) { + setPausedCondition(&s.StackitMachine.Status.Conditions, s.StackitMachine.Generation, paused, message) } func (s *MachineScope) SetReady() { @@ -84,34 +96,60 @@ func (s *MachineScope) SetNotReady(reason, message string, conditionTypes ...str s.SetConditions(metav1.ConditionFalse, reason, message, conditionTypes...) } -func (s *MachineScope) Tags() map[string]string { +// CredentialFailureResult records the failure and decides how to retry. +func (s *MachineScope) CredentialFailureResult( + err error, + requeueAfter time.Duration, + conditionTypes ...string, +) (ctrl.Result, error) { + s.SetNotReady("CredentialsInvalid", err.Error(), conditionTypes...) + return credentialFailureResult(err, requeueAfter) +} + +func (s *MachineScope) CloudFailureResult( + reason string, + err error, + requeueAfter time.Duration, + returnError bool, + conditionTypes ...string, +) (ctrl.Result, error) { + s.SetNotReady(reason, err.Error(), conditionTypes...) + return cloudFailureResult(err, requeueAfter, returnError) +} + +func (s *MachineScope) tags() map[string]string { return util.MachineTags( - s.Cluster.Name, - s.Cluster.Namespace, + s.cluster.Name, + s.cluster.Namespace, s.Machine.Name, string(s.Machine.UID), s.StackitMachine.Spec.AdditionalLabels, ) } -func (s *MachineScope) SetInstance(server *cloud.Server) string { - providerID := cloud.NewProviderID(s.StackitCluster.Spec.ProjectID, s.StackitCluster.Spec.Region, server.ID) - s.StackitMachine.Status.InstanceID = server.ID - s.StackitMachine.Status.InstanceState = server.State - s.StackitMachine.Status.AvailabilityZone = server.AvailabilityZone +func (s *MachineScope) setInstance(srv *server.Server, created bool) { + if srv == nil { + s.instanceCreated = false + s.instancePowerStatus = "" + s.StackitMachine.Status.Addresses = nil + s.StackitMachine.Status.InstanceID = "" + s.StackitMachine.Status.InstanceState = "" + s.StackitMachine.Status.AvailabilityZone = "" + return + } + s.instanceCreated = created + s.instancePowerStatus = srv.PowerStatus + s.StackitMachine.Status.Addresses = machineAddressesFromServer(srv.Addresses) + providerID := fmt.Sprintf("stackit://%s", srv.ID) + s.StackitMachine.Status.InstanceID = srv.ID + s.StackitMachine.Status.InstanceState = srv.State + s.StackitMachine.Status.AvailabilityZone = srv.AvailabilityZone s.StackitMachine.Spec.ProviderID = &providerID s.StackitMachine.Status.ProviderID = providerID s.StackitMachine.Status.Initialization.Provisioned = true - return providerID -} - -func (s *MachineScope) ClearInstance() { - s.StackitMachine.Status.InstanceID = "" - s.StackitMachine.Status.InstanceState = "" - s.StackitMachine.Status.AvailabilityZone = "" } -// AvailabilityZone returns the resolved availability zone for the machine. +// availabilityZone returns the resolved availability zone for the machine. // Following Cluster API conventions: // 1. If Machine.Spec.FailureDomain is set (e.g. by KCP spreading control plane nodes or MachineDeployment), // it is used. @@ -119,7 +157,7 @@ func (s *MachineScope) ClearInstance() { // 3. Otherwise, if neither is set, it defaults to the first available failure domain // from StackitCluster.Status.FailureDomains (sorted alphabetically). This prevents the STACKIT IaaS // API from defaulting to the expensive metro zone (eu01-m). -func (s *MachineScope) AvailabilityZone() string { +func (s *MachineScope) availabilityZone() string { if s.Machine != nil && s.Machine.Spec.FailureDomain != "" { return s.Machine.Spec.FailureDomain } @@ -128,20 +166,87 @@ func (s *MachineScope) AvailabilityZone() string { return s.StackitMachine.Spec.AvailabilityZone } - if s.StackitCluster != nil && len(s.StackitCluster.Status.FailureDomains) > 0 { - zones := make([]string, 0, len(s.StackitCluster.Status.FailureDomains)) - for _, fd := range s.StackitCluster.Status.FailureDomains { - zones = append(zones, fd.Name) - } - slices.Sort(zones) - return zones[0] + return defaultAvailabilityZone(s.StackitCluster) +} + +func (s *MachineScope) SetCloudClient(cloudClient cloud.Client) { + s.cloudClient = cloudClient +} + +func (s *MachineScope) ProjectID() string { + if s.StackitCluster.Spec.ProjectID != "" { + return s.StackitCluster.Spec.ProjectID } + return s.cloudClient.ProjectID() +} - if s.StackitCluster != nil && s.StackitCluster.Spec.Region != "" { - return s.StackitCluster.Spec.Region + "-1" +func (s *MachineScope) Region() string { + if s.StackitCluster.Spec.Region != "" { + return s.StackitCluster.Spec.Region } + return s.cloudClient.Region() +} - return "" +func (s *MachineScope) IaaSClient() *iaas.APIClient { + return s.cloudClient.IaaSClient() +} + +func (s *MachineScope) SetBootstrapData(data []byte) { + s.bootstrapData = data +} + +func (s *MachineScope) InstancePowerStatus() string { + return s.instancePowerStatus +} + +func (s *MachineScope) InstanceCreated() bool { + return s.instanceCreated +} + +func (s *MachineScope) ServerSpec() server.ServerSpec { + return server.ServerSpec{ + ID: s.StackitMachine.Status.InstanceID, + Name: s.StackitMachine.Name, + ImageID: s.StackitMachine.Spec.ImageID, + MachineType: s.StackitMachine.Spec.MachineType, + AvailabilityZone: s.availabilityZone(), + SSHKeyName: s.StackitMachine.Spec.SSHKeyName, + NetworkID: s.NetworkID(), + SecurityGroups: s.StackitMachine.Spec.SecurityGroups, + UserData: s.bootstrapData, + Tags: s.tags(), + RootVolume: rootVolumeFromSpec(s.StackitMachine.Spec.RootVolume), + DisallowRecreate: s.StackitMachine.Status.Initialization.Provisioned, + SetServer: s.setInstance, + } +} + +func (s *MachineScope) SecurityGroupSpecs() []securitygroup.SecurityGroupSpec { + if !s.StackitCluster.Spec.Bastion.Enabled { + return nil + } + return []securitygroup.SecurityGroupSpec{ + nodeSSHSecurityGroupSpec( + s.StackitCluster, + s.StackitCluster.Status.Bastion.SecurityGroupID, + s.StackitMachine.Status.InstanceID, + ), + } +} + +func machineAddressesFromServer(in []server.Address) []clusterv1.MachineAddress { + if len(in) == 0 { + return nil + } + + out := make([]clusterv1.MachineAddress, len(in)) + for i, address := range in { + out[i] = clusterv1.MachineAddress{ + Type: clusterv1.MachineAddressType(address.Type), + Address: address.Address, + } + } + return out } // NetworkID returns the network ID for this machine, resolving in order: diff --git a/scope/scope_test.go b/scope/scope_test.go deleted file mode 100644 index 649ad7f..0000000 --- a/scope/scope_test.go +++ /dev/null @@ -1,117 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package scope - -import ( - "testing" - - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" -) - -func TestMachineScopeNetworkID(t *testing.T) { - tests := []struct { - name string - stackitMachine *infrav1.StackitMachine - stackitCluster *infrav1.StackitCluster - want string - }{ - { - name: "machine-level network override takes precedence", - stackitMachine: &infrav1.StackitMachine{ - Spec: infrav1.StackitMachineSpec{ - Network: infrav1.StackitMachineNetworkSpec{ID: "machine-network-id"}, - }, - }, - stackitCluster: &infrav1.StackitCluster{ - Spec: infrav1.StackitClusterSpec{ - Network: infrav1.StackitClusterNetworkSpec{ID: "cluster-spec-id"}, - }, - Status: infrav1.StackitClusterStatus{ - Network: infrav1.StackitNetworkStatus{ID: "cluster-status-id", Managed: true}, - }, - }, - want: "machine-network-id", - }, - { - name: "falls back to BYO cluster spec network ID when machine has none", - stackitMachine: &infrav1.StackitMachine{ - Spec: infrav1.StackitMachineSpec{}, - }, - stackitCluster: &infrav1.StackitCluster{ - Spec: infrav1.StackitClusterSpec{ - Network: infrav1.StackitClusterNetworkSpec{ID: "cluster-byo-id"}, - }, - }, - want: "cluster-byo-id", - }, - { - name: "falls back to managed cluster status network ID when spec has none", - stackitMachine: &infrav1.StackitMachine{ - Spec: infrav1.StackitMachineSpec{}, - }, - stackitCluster: &infrav1.StackitCluster{ - Spec: infrav1.StackitClusterSpec{}, - Status: infrav1.StackitClusterStatus{ - Network: infrav1.StackitNetworkStatus{ID: "cluster-managed-status-id", Managed: true}, - }, - }, - want: "cluster-managed-status-id", - }, - { - name: "returns empty when no network is configured anywhere", - stackitMachine: &infrav1.StackitMachine{ - Spec: infrav1.StackitMachineSpec{}, - }, - stackitCluster: &infrav1.StackitCluster{ - Spec: infrav1.StackitClusterSpec{}, - }, - want: "", - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - scope := &MachineScope{ - StackitMachine: tt.stackitMachine, - StackitCluster: tt.stackitCluster, - } - if got := scope.NetworkID(); got != tt.want { - t.Errorf("NetworkID() = %q, want %q", got, tt.want) - } - }) - } -} - -func TestClusterScopeNetworkID(t *testing.T) { - clusterBYO := &infrav1.StackitCluster{ - ObjectMeta: metav1.ObjectMeta{Name: "byo-cluster"}, - Spec: infrav1.StackitClusterSpec{ - Network: infrav1.StackitClusterNetworkSpec{ID: "byo-id"}, - }, - } - scopeBYO := &ClusterScope{StackitCluster: clusterBYO} - if got := scopeBYO.NetworkID(); got != "byo-id" { - t.Errorf("ClusterScope.NetworkID() = %q, want byo-id", got) - } - - clusterManaged := &infrav1.StackitCluster{ - ObjectMeta: metav1.ObjectMeta{Name: "managed-cluster"}, - Status: infrav1.StackitClusterStatus{ - Network: infrav1.StackitNetworkStatus{ID: "managed-status-id", Managed: true}, - }, - } - scopeManaged := &ClusterScope{StackitCluster: clusterManaged} - if got := scopeManaged.NetworkID(); got != "managed-status-id" { - t.Errorf("ClusterScope.NetworkID() = %q, want managed-status-id", got) - } -} diff --git a/test/e2e/e2e_test.go b/test/e2e/e2e_test.go index 224d56a..9c39078 100644 --- a/test/e2e/e2e_test.go +++ b/test/e2e/e2e_test.go @@ -412,41 +412,17 @@ var _ = Describe("Manager", Ordered, func() { }, 10*time.Minute, 10*time.Second).Should(Succeed()) By("waiting for the StackitMachine to provision a VM") - var instanceID string Eventually(func(g Gomega) { ready := kubectlOutput(g, "get", "stackitmachine", machineName, "-n", cfg.Namespace, "-o", "jsonpath={.status.ready}") g.Expect(ready).To(Equal("true")) - instanceID = kubectlOutput(g, "get", "stackitmachine", machineName, "-n", cfg.Namespace, "-o", "jsonpath={.status.instanceID}") + instanceID := kubectlOutput(g, "get", "stackitmachine", machineName, "-n", cfg.Namespace, "-o", "jsonpath={.status.instanceID}") g.Expect(instanceID).NotTo(BeEmpty()) }, 25*time.Minute, 15*time.Second).Should(Succeed()) - By("verifying the VM exists in STACKIT") - Eventually(func(g Gomega) { - server, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(server.ID).To(Equal(instanceID)) - }, 5*time.Minute, 15*time.Second).Should(Succeed()) - By("deleting the StackitMachine to trigger VM cleanup") cmd = exec.Command("kubectl", "delete", "stackitmachine", machineName, "-n", cfg.Namespace, "--wait=true", "--timeout=20m") _, err = utils.Run(cmd) Expect(err).NotTo(HaveOccurred(), "Failed to delete StackitMachine") - - By("verifying the VM was deleted from STACKIT") - Eventually(func(g Gomega) { - _, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(cloud.IsNotFound(err)).To(BeTrue(), "expected server %s to be deleted, got %v", instanceID, err) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - }, 5*time.Minute, 15*time.Second).Should(Succeed()) }) It("should create and delete a 1 control-plane / 1 worker workload Cluster without STACKIT leaks", func() { @@ -486,51 +462,23 @@ var _ = Describe("Manager", Ordered, func() { }, 15*time.Minute, 10*time.Second).Should(Succeed()) if cfg.BastionEnabled { - By("verifying the bastion public IP and security group exist") + By("verifying the bastion status is populated") Eventually(func(g Gomega) { output := kubectlOutput(g, "get", "stackitcluster", clusterName, "-n", cfg.Namespace, "-o", "jsonpath={.status.bastion.publicIP}") g.Expect(output).NotTo(BeEmpty()) - publicIPs, err := cloudClient.ListPublicIPsByTags(ctx, stackitE2EBastionTags(testID)) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(publicIPs).To(HaveLen(1)) - securityGroups, err := cloudClient.ListSecurityGroupsByTags(ctx, stackitE2EBastionTags(testID)) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(securityGroups).To(HaveLen(1)) }, 10*time.Minute, 15*time.Second).Should(Succeed()) } By("waiting for one control-plane and one worker StackitMachine to provision") - var instanceIDs []string Eventually(func(g Gomega) { machines := stackitMachinesForTestID(g, cfg.Namespace, testID) g.Expect(machines).To(HaveLen(2)) - instanceIDs = instanceIDs[:0] for _, machine := range machines { g.Expect(machine.Status.Ready).To(BeTrue(), "StackitMachine %s is not ready", machine.Metadata.Name) g.Expect(machine.Status.InstanceID).NotTo(BeEmpty(), "StackitMachine %s has no instanceID", machine.Metadata.Name) - instanceIDs = append(instanceIDs, machine.Status.InstanceID) } }, 45*time.Minute, 15*time.Second).Should(Succeed()) - if cfg.BastionEnabled { - By("verifying the node SSH security group exists") - Eventually(func(g Gomega) { - securityGroups, err := cloudClient.ListSecurityGroupsByTags(ctx, stackitE2ENodeSSHTags(testID)) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(securityGroups).To(HaveLen(1)) - }, 10*time.Minute, 15*time.Second).Should(Succeed()) - } - - By("verifying both VMs exist in STACKIT") - for _, instanceID := range instanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - server, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(server.ID).To(Equal(instanceID)) - }, 5*time.Minute, 15*time.Second).Should(Succeed()) - } - By("deleting the workload Cluster") cmd = exec.Command("kubectl", "delete", "cluster", clusterName, "-n", cfg.Namespace, "--wait=true", "--timeout=45m") _, err = utils.Run(cmd) @@ -547,25 +495,6 @@ var _ = Describe("Manager", Ordered, func() { g.Expect(output).To(BeEmpty()) g.Expect(stackitMachinesForTestID(g, cfg.Namespace, testID)).To(BeEmpty()) }, 5*time.Minute, 10*time.Second).Should(Succeed()) - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - publicIPs, err := cloudClient.ListPublicIPsByTags(ctx, stackitE2EBastionTags(testID)) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(publicIPs).To(BeEmpty()) - securityGroups, err := cloudClient.ListSecurityGroupsByTags(ctx, stackitE2EBastionTags(testID)) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(securityGroups).To(BeEmpty()) - securityGroups, err = cloudClient.ListSecurityGroupsByTags(ctx, stackitE2ENodeSSHTags(testID)) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(securityGroups).To(BeEmpty()) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) }) It("should align StackitMachine, Machine, and Node providerIDs in a real workload Cluster", func() { @@ -584,7 +513,6 @@ var _ = Describe("Manager", Ordered, func() { leakTags := stackitE2ETags(testID) kubernetesVersion := envDefault("KUBERNETES_VERSION", defaultKubernetesVersion) validateSupportedKubernetesVersion(kubernetesVersion) - observedInstanceIDs := []string{} By("cleaning up stale STACKIT resources for the e2e test ID") Expect(cloud.CleanupByTags(ctx, cloudClient, leakTags)).To(Succeed()) @@ -595,7 +523,6 @@ var _ = Describe("Manager", Ordered, func() { var workloadKubeconfig string defer func() { cleanupStackitKubeadmClusterFixture(clusterName, cfg.Namespace) - cleanupCloudServersByID(ctx, cloudClient, observedInstanceIDs) if err := cloud.CleanupByTags(ctx, cloudClient, leakTags); err != nil { _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API cleanup warning: %v\n", err) } @@ -610,30 +537,19 @@ var _ = Describe("Manager", Ordered, func() { Expect(err).NotTo(HaveOccurred(), "Failed to apply STACKIT NodeRef fixture") waitForKubeadmWorkloadClusterReady(workloadReadinessOptions{ - Namespace: cfg.Namespace, - ClusterName: clusterName, - TestID: testID, - WantNodes: 2, - WantMachines: 2, - InstallCNI: true, - WaitForCCM: true, - ObservedInstanceIDs: &observedInstanceIDs, + Namespace: cfg.Namespace, + ClusterName: clusterName, + TestID: testID, + WantNodes: 2, + WantMachines: 2, + InstallCNI: true, + WaitForCCM: true, }, &workloadKubeconfig) By("deleting the workload Cluster") cmd = exec.Command("kubectl", "delete", "cluster", clusterName, "-n", cfg.Namespace, "--wait=true", "--timeout=45m") _, err = utils.Run(cmd) Expect(err).NotTo(HaveOccurred(), "Failed to delete NodeRef workload Cluster") - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) }) It("should create a topology workload Cluster with Ready Nodes", func() { @@ -652,7 +568,6 @@ var _ = Describe("Manager", Ordered, func() { leakTags := stackitE2ETags(testID) kubernetesVersion := envDefault("KUBERNETES_VERSION", defaultKubernetesVersion) validateSupportedKubernetesVersion(kubernetesVersion) - observedInstanceIDs := []string{} By("cleaning up stale STACKIT resources for the e2e test ID") Expect(cloud.CleanupByTags(ctx, cloudClient, leakTags)).To(Succeed()) @@ -676,7 +591,6 @@ var _ = Describe("Manager", Ordered, func() { var workloadKubeconfig string defer func() { cleanupStackitTopologyClusterFixture(clusterName, cfg.Namespace) - cleanupCloudServersByID(ctx, cloudClient, observedInstanceIDs) if err := cloud.CleanupByTags(ctx, cloudClient, leakTags); err != nil { _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API cleanup warning: %v\n", err) } @@ -692,15 +606,14 @@ var _ = Describe("Manager", Ordered, func() { Expect(err).NotTo(HaveOccurred(), "Failed to apply STACKIT topology workload fixture") waitForKubeadmWorkloadClusterReady(workloadReadinessOptions{ - Namespace: cfg.Namespace, - ClusterName: clusterName, - TestID: testID, - WantNodes: 2, - WantMachines: 2, - InstallCNI: true, - WaitForCCM: true, - Topology: true, - ObservedInstanceIDs: &observedInstanceIDs, + Namespace: cfg.Namespace, + ClusterName: clusterName, + TestID: testID, + WantNodes: 2, + WantMachines: 2, + InstallCNI: true, + WaitForCCM: true, + Topology: true, }, &workloadKubeconfig) By("verifying topology template metadata is propagated to generated infrastructure resources") @@ -719,16 +632,6 @@ var _ = Describe("Manager", Ordered, func() { g.Expect(kubectlOutput(g, "get", "stackitmachine", "-n", cfg.Namespace, "-l", "cluster.x-k8s.io/cluster-name="+clusterName, "-o", "name")).To(BeEmpty()) g.Expect(kubectlOutput(g, "get", "stackitcluster", "-n", cfg.Namespace, "-l", "cluster.x-k8s.io/cluster-name="+clusterName, "-o", "name")).To(BeEmpty()) }, 10*time.Minute, 15*time.Second).Should(Succeed()) - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) }) It("should scale a worker MachineDeployment up and down without STACKIT leaks", func() { @@ -743,7 +646,6 @@ var _ = Describe("Manager", Ordered, func() { testID := envDefault("STACKIT_E2E_TEST_ID", clusterName) leakTags := stackitE2ETags(testID) machineDeploymentName := clusterName + "-md-0" - observedInstanceIDs := []string{} By("cleaning up stale STACKIT resources for the e2e test ID") Expect(cloud.CleanupByTags(ctx, cloudClient, leakTags)).To(Succeed()) @@ -755,7 +657,6 @@ var _ = Describe("Manager", Ordered, func() { fixturePath := writeTempManifest("stackit-md-scale-e2e-*.yaml", fixture) defer func() { cleanupStackitMachineDeploymentScaleFixture(clusterName, cfg.Namespace) - cleanupCloudServersByID(ctx, cloudClient, observedInstanceIDs) if err := cloud.CleanupByTags(ctx, cloudClient, leakTags); err != nil { _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API cleanup warning: %v\n", err) } @@ -777,7 +678,6 @@ var _ = Describe("Manager", Ordered, func() { Eventually(func(g Gomega) { initialInstanceIDs = readyStackitMachineInstanceIDs(g, cfg.Namespace, testID, 1) }, 45*time.Minute, 15*time.Second).Should(Succeed()) - observedInstanceIDs = appendUnique(observedInstanceIDs, initialInstanceIDs...) Eventually(func(g Gomega) { expectCAPIMachinesWithProviderIDs(g, cfg.Namespace, clusterName, 1) }, 5*time.Minute, 10*time.Second).Should(Succeed()) @@ -791,7 +691,6 @@ var _ = Describe("Manager", Ordered, func() { Eventually(func(g Gomega) { scaledUpInstanceIDs = readyStackitMachineInstanceIDs(g, cfg.Namespace, testID, 3) }, 45*time.Minute, 15*time.Second).Should(Succeed()) - observedInstanceIDs = appendUnique(observedInstanceIDs, scaledUpInstanceIDs...) Eventually(func(g Gomega) { expectCAPIMachinesWithProviderIDs(g, cfg.Namespace, clusterName, 3) }, 5*time.Minute, 10*time.Second).Should(Succeed()) @@ -799,16 +698,6 @@ var _ = Describe("Manager", Ordered, func() { Expect(scaledUpInstanceIDs).To(ContainElement(instanceID)) } - By("verifying all scaled-up worker VMs exist in STACKIT") - for _, instanceID := range scaledUpInstanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - server, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(server.ID).To(Equal(instanceID)) - }, 5*time.Minute, 15*time.Second).Should(Succeed()) - } - By("scaling workers back down to one replica") cmd = exec.Command("kubectl", "scale", "machinedeployment", machineDeploymentName, "-n", cfg.Namespace, "--replicas=1") _, err = utils.Run(cmd) @@ -818,7 +707,6 @@ var _ = Describe("Manager", Ordered, func() { Eventually(func(g Gomega) { remainingInstanceIDs = readyStackitMachineInstanceIDs(g, cfg.Namespace, testID, 1) }, 30*time.Minute, 15*time.Second).Should(Succeed()) - observedInstanceIDs = appendUnique(observedInstanceIDs, remainingInstanceIDs...) Eventually(func(g Gomega) { expectCAPIMachinesWithProviderIDs(g, cfg.Namespace, clusterName, 1) }, 5*time.Minute, 10*time.Second).Should(Succeed()) @@ -826,38 +714,10 @@ var _ = Describe("Manager", Ordered, func() { deletedInstanceIDs := difference(scaledUpInstanceIDs, remainingInstanceIDs) Expect(deletedInstanceIDs).To(HaveLen(2)) - By("verifying scaled-down worker VMs were deleted from STACKIT") - for _, instanceID := range deletedInstanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - _, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(cloud.IsNotFound(err)).To(BeTrue(), "expected server %s to be deleted, got %v", instanceID, err) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) - } - By("deleting the scale test workload Cluster") cmd = exec.Command("kubectl", "delete", "cluster", clusterName, "-n", cfg.Namespace, "--wait=true", "--timeout=45m") _, err = utils.Run(cmd) Expect(err).NotTo(HaveOccurred(), "Failed to delete scale test workload Cluster") - - By("verifying all observed worker VMs were deleted from STACKIT") - for _, instanceID := range observedInstanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - _, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(cloud.IsNotFound(err)).To(BeTrue(), "expected server %s to be deleted, got %v", instanceID, err) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) - } - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) }) It("should scale workload worker Nodes up and down without STACKIT leaks", func() { @@ -877,7 +737,6 @@ var _ = Describe("Manager", Ordered, func() { machineDeploymentName := clusterName + "-md-0" kubernetesVersion := envDefault("KUBERNETES_VERSION", defaultKubernetesVersion) validateSupportedKubernetesVersion(kubernetesVersion) - observedInstanceIDs := []string{} By("cleaning up stale STACKIT resources for the e2e test ID") Expect(cloud.CleanupByTags(ctx, cloudClient, leakTags)).To(Succeed()) @@ -898,7 +757,6 @@ var _ = Describe("Manager", Ordered, func() { var workloadKubeconfig string defer func() { cleanupStackitKubeadmClusterFixture(clusterName, cfg.Namespace) - cleanupCloudServersByID(ctx, cloudClient, observedInstanceIDs) if err := cloud.CleanupByTags(ctx, cloudClient, leakTags); err != nil { _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API cleanup warning: %v\n", err) } @@ -913,14 +771,13 @@ var _ = Describe("Manager", Ordered, func() { Expect(err).NotTo(HaveOccurred(), "Failed to apply STACKIT workload scale fixture") waitForKubeadmWorkloadClusterReady(workloadReadinessOptions{ - Namespace: cfg.Namespace, - ClusterName: clusterName, - TestID: testID, - WantNodes: 2, - WantMachines: 2, - InstallCNI: true, - WaitForCCM: true, - ObservedInstanceIDs: &observedInstanceIDs, + Namespace: cfg.Namespace, + ClusterName: clusterName, + TestID: testID, + WantNodes: 2, + WantMachines: 2, + InstallCNI: true, + WaitForCCM: true, }, &workloadKubeconfig) var initialWorkerNodeNames []string @@ -950,22 +807,11 @@ var _ = Describe("Manager", Ordered, func() { expectWorkloadNodesReady(g, workloadKubeconfig, 4) scaledUpWorkerNodeNames = nodeNamesForMachines(workers) }, 45*time.Minute, 15*time.Second).Should(Succeed()) - observedInstanceIDs = appendUnique(observedInstanceIDs, scaledUpInstanceIDs...) Expect(scaledUpWorkerNodeNames).To(HaveLen(3)) for _, nodeName := range initialWorkerNodeNames { Expect(scaledUpWorkerNodeNames).To(ContainElement(nodeName)) } - By("verifying all scaled-up workload VMs exist in STACKIT") - for _, instanceID := range scaledUpInstanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - server, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(server.ID).To(Equal(instanceID)) - }, 5*time.Minute, 15*time.Second).Should(Succeed()) - } - By("scaling workload workers back down to one replica") cmd = exec.Command("kubectl", "scale", "machinedeployment", machineDeploymentName, "-n", cfg.Namespace, "--replicas=1") _, err = utils.Run(cmd) @@ -983,7 +829,6 @@ var _ = Describe("Manager", Ordered, func() { expectWorkloadNodesReady(g, workloadKubeconfig, 2) remainingWorkerNodeNames = nodeNamesForMachines(workers) }, 30*time.Minute, 15*time.Second).Should(Succeed()) - observedInstanceIDs = appendUnique(observedInstanceIDs, remainingInstanceIDs...) removedWorkerNodeNames := difference(scaledUpWorkerNodeNames, remainingWorkerNodeNames) Expect(removedWorkerNodeNames).To(HaveLen(2)) @@ -996,29 +841,10 @@ var _ = Describe("Manager", Ordered, func() { deletedInstanceIDs := difference(scaledUpInstanceIDs, remainingInstanceIDs) Expect(deletedInstanceIDs).To(HaveLen(2)) - By("verifying scaled-down workload VMs were deleted from STACKIT") - for _, instanceID := range deletedInstanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - _, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(cloud.IsNotFound(err)).To(BeTrue(), "expected server %s to be deleted, got %v", instanceID, err) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) - } - By("deleting the workload scale Cluster") cmd = exec.Command("kubectl", "delete", "cluster", clusterName, "-n", cfg.Namespace, "--wait=true", "--timeout=45m") _, err = utils.Run(cmd) Expect(err).NotTo(HaveOccurred(), "Failed to delete workload scale Cluster") - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) }) It("should replace worker VMs during a MachineDeployment version upgrade without STACKIT leaks", func() { @@ -1037,7 +863,6 @@ var _ = Describe("Manager", Ordered, func() { upgradeTo := envDefault("STACKIT_E2E_UPGRADE_TO", "v1.34.8") validateSupportedKubernetesVersion(upgradeFrom) validateSupportedKubernetesVersion(upgradeTo) - observedInstanceIDs := []string{} By("cleaning up stale STACKIT resources for the e2e test ID") Expect(cloud.CleanupByTags(ctx, cloudClient, leakTags)).To(Succeed()) @@ -1047,7 +872,6 @@ var _ = Describe("Manager", Ordered, func() { fixturePath := writeTempManifest("stackit-md-upgrade-e2e-*.yaml", fixture) defer func() { cleanupStackitMachineDeploymentScaleFixture(clusterName, cfg.Namespace) - cleanupCloudServersByID(ctx, cloudClient, observedInstanceIDs) if err := cloud.CleanupByTags(ctx, cloudClient, leakTags); err != nil { _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API cleanup warning: %v\n", err) } @@ -1069,7 +893,6 @@ var _ = Describe("Manager", Ordered, func() { Eventually(func(g Gomega) { initialInstanceIDs = readyStackitMachineInstanceIDs(g, cfg.Namespace, testID, 1) }, 45*time.Minute, 15*time.Second).Should(Succeed()) - observedInstanceIDs = appendUnique(observedInstanceIDs, initialInstanceIDs...) Eventually(func(g Gomega) { expectCAPIMachinesWithProviderIDs(g, cfg.Namespace, clusterName, 1) }, 5*time.Minute, 10*time.Second).Should(Succeed()) @@ -1087,7 +910,6 @@ var _ = Describe("Manager", Ordered, func() { g.Expect(instanceIDs(upgradedMachines)).To(ContainElement(initialInstanceIDs[0])) }, 45*time.Minute, 15*time.Second).Should(Succeed()) upgradedInstanceIDs := instanceIDs(upgradedMachines) - observedInstanceIDs = appendUnique(observedInstanceIDs, upgradedInstanceIDs...) Eventually(func(g Gomega) { expectCAPIMachinesWithProviderIDs(g, cfg.Namespace, clusterName, 2) }, 5*time.Minute, 10*time.Second).Should(Succeed()) @@ -1106,38 +928,10 @@ var _ = Describe("Manager", Ordered, func() { g.Expect(remainingInstanceIDs).To(Equal(replacementInstanceIDs)) }, 20*time.Minute, 15*time.Second).Should(Succeed()) - By("verifying the old worker VM was deleted from STACKIT") - Eventually(func(g Gomega) { - _, err := cloudClient.GetServer(ctx, initialInstanceIDs[0]) - g.Expect(cloud.IsNotFound(err)).To(BeTrue(), "expected old server %s to be deleted, got %v", initialInstanceIDs[0], err) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) - By("deleting the upgraded workload Cluster") cmd = exec.Command("kubectl", "delete", "cluster", clusterName, "-n", cfg.Namespace, "--wait=true", "--timeout=45m") _, err = utils.Run(cmd) Expect(err).NotTo(HaveOccurred(), "Failed to delete upgraded workload Cluster") - - By("ensuring all observed worker VMs are deleted via the STACKIT API") - cleanupCloudServersByID(ctx, cloudClient, observedInstanceIDs) - - By("verifying all observed worker VMs were deleted from STACKIT") - for _, instanceID := range observedInstanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - _, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(cloud.IsNotFound(err)).To(BeTrue(), "expected server %s to be deleted, got %v", instanceID, err) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) - } - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) }) It("should complete a workload worker MachineDeployment upgrade with Ready Nodes", func() { @@ -1159,7 +953,6 @@ var _ = Describe("Manager", Ordered, func() { upgradeTo := envDefault("STACKIT_E2E_UPGRADE_TO", "v1.35.4") validateSupportedKubernetesVersion(upgradeFrom) validateSupportedKubernetesVersion(upgradeTo) - observedInstanceIDs := []string{} By("cleaning up stale STACKIT resources for the e2e test ID") Expect(cloud.CleanupByTags(ctx, cloudClient, leakTags)).To(Succeed()) @@ -1180,7 +973,6 @@ var _ = Describe("Manager", Ordered, func() { var workloadKubeconfig string defer func() { cleanupStackitKubeadmClusterFixture(clusterName, cfg.Namespace) - cleanupCloudServersByID(ctx, cloudClient, observedInstanceIDs) if err := cloud.CleanupByTags(ctx, cloudClient, leakTags); err != nil { _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API cleanup warning: %v\n", err) } @@ -1195,14 +987,13 @@ var _ = Describe("Manager", Ordered, func() { Expect(err).NotTo(HaveOccurred(), "Failed to apply STACKIT workload worker upgrade fixture") waitForKubeadmWorkloadClusterReady(workloadReadinessOptions{ - Namespace: cfg.Namespace, - ClusterName: clusterName, - TestID: testID, - WantNodes: 3, - WantMachines: 3, - InstallCNI: true, - WaitForCCM: true, - ObservedInstanceIDs: &observedInstanceIDs, + Namespace: cfg.Namespace, + ClusterName: clusterName, + TestID: testID, + WantNodes: 3, + WantMachines: 3, + InstallCNI: true, + WaitForCCM: true, }, &workloadKubeconfig) var initialWorkerNodeNames []string @@ -1218,7 +1009,6 @@ var _ = Describe("Manager", Ordered, func() { }, 5*time.Minute, 10*time.Second).Should(Succeed()) Expect(initialWorkerNodeNames).To(HaveLen(2)) Expect(initialWorkerInstanceIDs).To(HaveLen(2)) - observedInstanceIDs = appendUnique(observedInstanceIDs, initialWorkerInstanceIDs...) By("patching the workload worker MachineDeployment Kubernetes version") patch := fmt.Sprintf(`{"spec":{"template":{"spec":{"version":"%s"}}}}`, upgradeTo) @@ -1230,8 +1020,7 @@ var _ = Describe("Manager", Ordered, func() { var upgradedWorkerInstanceIDs []string Eventually(func(g Gomega) { expectMachineDeploymentRollout(g, cfg.Namespace, machineDeploymentName, 2) - machines := readyStackitMachines(g, cfg.Namespace, testID, 3) - observedInstanceIDs = appendUnique(observedInstanceIDs, instanceIDs(machines)...) + _ = readyStackitMachines(g, cfg.Namespace, testID, 3) workers := workerMachinesForDeployment(g, cfg.Namespace, clusterName, machineDeploymentName) g.Expect(workers).To(HaveLen(2)) expectMachinesVersion(g, workers, upgradeTo) @@ -1254,29 +1043,10 @@ var _ = Describe("Manager", Ordered, func() { deletedInstanceIDs := difference(initialWorkerInstanceIDs, upgradedWorkerInstanceIDs) Expect(deletedInstanceIDs).To(HaveLen(2)) - By("verifying old workload worker VMs were deleted from STACKIT") - for _, instanceID := range deletedInstanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - _, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(cloud.IsNotFound(err)).To(BeTrue(), "expected old server %s to be deleted, got %v", instanceID, err) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) - } - By("deleting the workload worker upgrade Cluster") cmd = exec.Command("kubectl", "delete", "cluster", clusterName, "-n", cfg.Namespace, "--wait=true", "--timeout=45m") _, err = utils.Run(cmd) Expect(err).NotTo(HaveOccurred(), "Failed to delete workload worker upgrade Cluster") - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) }) It("should complete a workload control-plane upgrade with a Ready Node", func() { @@ -1298,7 +1068,6 @@ var _ = Describe("Manager", Ordered, func() { upgradeTo := envDefault("STACKIT_E2E_UPGRADE_TO", "v1.35.4") validateSupportedKubernetesVersion(upgradeFrom) validateSupportedKubernetesVersion(upgradeTo) - observedInstanceIDs := []string{} By("cleaning up stale STACKIT resources for the e2e test ID") Expect(cloud.CleanupByTags(ctx, cloudClient, leakTags)).To(Succeed()) @@ -1319,7 +1088,6 @@ var _ = Describe("Manager", Ordered, func() { var workloadKubeconfig string defer func() { cleanupStackitKubeadmClusterFixture(clusterName, cfg.Namespace) - cleanupCloudServersByID(ctx, cloudClient, observedInstanceIDs) if err := cloud.CleanupByTags(ctx, cloudClient, leakTags); err != nil { _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API cleanup warning: %v\n", err) } @@ -1334,14 +1102,13 @@ var _ = Describe("Manager", Ordered, func() { Expect(err).NotTo(HaveOccurred(), "Failed to apply STACKIT workload control-plane upgrade fixture") waitForKubeadmWorkloadClusterReady(workloadReadinessOptions{ - Namespace: cfg.Namespace, - ClusterName: clusterName, - TestID: testID, - WantNodes: 2, - WantMachines: 2, - InstallCNI: true, - WaitForCCM: true, - ObservedInstanceIDs: &observedInstanceIDs, + Namespace: cfg.Namespace, + ClusterName: clusterName, + TestID: testID, + WantNodes: 2, + WantMachines: 2, + InstallCNI: true, + WaitForCCM: true, }, &workloadKubeconfig) var initialControlPlaneInstanceIDs []string @@ -1354,7 +1121,6 @@ var _ = Describe("Manager", Ordered, func() { initialControlPlaneInstanceIDs = stackitInstanceIDsForMachines(g, cfg.Namespace, testID, controlPlanes) }, 5*time.Minute, 10*time.Second).Should(Succeed()) Expect(initialControlPlaneInstanceIDs).To(HaveLen(1)) - observedInstanceIDs = appendUnique(observedInstanceIDs, initialControlPlaneInstanceIDs...) By("patching the workload KubeadmControlPlane Kubernetes version") patch := fmt.Sprintf(`{"spec":{"version":"%s"}}`, upgradeTo) @@ -1367,8 +1133,7 @@ var _ = Describe("Manager", Ordered, func() { output := kubectlOutputWithKubeconfig(g, workloadKubeconfig, "get", "ns", "kube-system", "-o", "name") g.Expect(output).To(Equal("namespace/kube-system")) expectKubeadmControlPlaneRollout(g, cfg.Namespace, kubeadmControlPlaneName, 1) - machines := readyStackitMachines(g, cfg.Namespace, testID, 2) - observedInstanceIDs = appendUnique(observedInstanceIDs, instanceIDs(machines)...) + _ = readyStackitMachines(g, cfg.Namespace, testID, 2) controlPlanes := controlPlaneMachinesForCluster(g, cfg.Namespace, clusterName) g.Expect(controlPlanes).To(HaveLen(1)) expectMachinesVersion(g, controlPlanes, upgradeTo) @@ -1378,30 +1143,10 @@ var _ = Describe("Manager", Ordered, func() { }, 60*time.Minute, 15*time.Second).Should(Succeed()) Expect(upgradedControlPlaneInstanceIDs).To(HaveLen(1)) - deletedInstanceIDs := difference(initialControlPlaneInstanceIDs, upgradedControlPlaneInstanceIDs) - By("verifying old workload control-plane VMs were deleted from STACKIT when replaced") - for _, instanceID := range deletedInstanceIDs { - instanceID := instanceID - Eventually(func(g Gomega) { - _, err := cloudClient.GetServer(ctx, instanceID) - g.Expect(cloud.IsNotFound(err)).To(BeTrue(), "expected old server %s to be deleted, got %v", instanceID, err) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) - } - By("deleting the workload control-plane upgrade Cluster") cmd = exec.Command("kubectl", "delete", "cluster", clusterName, "-n", cfg.Namespace, "--wait=true", "--timeout=45m") _, err = utils.Run(cmd) Expect(err).NotTo(HaveOccurred(), "Failed to delete workload control-plane upgrade Cluster") - - By("verifying no tagged STACKIT resources remain for the e2e test ID") - Eventually(func(g Gomega) { - servers, err := cloudClient.ListServersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(servers).To(BeEmpty()) - loadBalancers, err := cloudClient.ListAPIServerLoadBalancersByTags(ctx, leakTags) - g.Expect(err).NotTo(HaveOccurred()) - g.Expect(loadBalancers).To(BeEmpty()) - }, 20*time.Minute, 15*time.Second).Should(Succeed()) }) }) }) @@ -1448,15 +1193,14 @@ type topologyWorkloadFixtureOptions struct { } type workloadReadinessOptions struct { - Namespace string - ClusterName string - TestID string - WantNodes int - WantMachines int - InstallCNI bool - WaitForCCM bool - Topology bool - ObservedInstanceIDs *[]string + Namespace string + ClusterName string + TestID string + WantNodes int + WantMachines int + InstallCNI bool + WaitForCCM bool + Topology bool } func stackitVMConfigFromEnv() stackitVMConfig { @@ -2351,18 +2095,6 @@ func stackitE2ETags(testID string) map[string]string { } } -func stackitE2EBastionTags(testID string) map[string]string { - tags := stackitE2ETags(testID) - tags[util.LabelResourceRole] = util.ResourceRoleBastion - return tags -} - -func stackitE2ENodeSSHTags(testID string) map[string]string { - tags := stackitE2ETags(testID) - tags[util.LabelResourceRole] = util.ResourceRoleNodeSSH - return tags -} - func cleanupStackitClusterFixture(clusterName, namespace string) { for _, args := range [][]string{ {"delete", "cluster", clusterName, "-n", namespace, "--ignore-not-found", "--wait=true", "--timeout=45m"}, @@ -2720,14 +2452,12 @@ func waitForKubeadmWorkloadClusterReady(opts workloadReadinessOptions, workloadK if opts.Topology { By("waiting for the topology control-plane VM to provision") Eventually(func(g Gomega) { - machine := readyTopologyControlPlaneStackitMachine(g, opts.Namespace, opts.ClusterName, opts.TestID) - appendObservedInstanceIDs(opts.ObservedInstanceIDs, machine.Status.InstanceID) + _ = readyTopologyControlPlaneStackitMachine(g, opts.Namespace, opts.ClusterName, opts.TestID) }, 45*time.Minute, 15*time.Second).Should(Succeed()) } else { By("waiting for the control-plane VM to provision") Eventually(func(g Gomega) { - machine := readyStackitMachineByNamePart(g, opts.Namespace, opts.TestID, "control-plane") - appendObservedInstanceIDs(opts.ObservedInstanceIDs, machine.Status.InstanceID) + _ = readyStackitMachineByNamePart(g, opts.Namespace, opts.TestID, "control-plane") }, 45*time.Minute, 15*time.Second).Should(Succeed()) } @@ -2750,8 +2480,7 @@ func waitForKubeadmWorkloadClusterReady(opts workloadReadinessOptions, workloadK By("waiting for workload StackitMachines to provision") Eventually(func(g Gomega) { - machines := readyStackitMachines(g, opts.Namespace, opts.TestID, opts.WantMachines) - appendObservedInstanceIDs(opts.ObservedInstanceIDs, instanceIDs(machines)...) + _ = readyStackitMachines(g, opts.Namespace, opts.TestID, opts.WantMachines) }, 45*time.Minute, 15*time.Second).Should(Succeed()) By("waiting for workload Nodes to be Ready") @@ -2765,13 +2494,6 @@ func waitForKubeadmWorkloadClusterReady(opts workloadReadinessOptions, workloadK }, 15*time.Minute, 10*time.Second).Should(Succeed()) } -func appendObservedInstanceIDs(observed *[]string, instanceIDs ...string) { - if observed == nil { - return - } - *observed = appendUnique(*observed, instanceIDs...) -} - func waitForWorkloadCCMRollout(kubeconfig string) { Eventually(func(g Gomega) { cmd := exec.Command("kubectl", "--kubeconfig", kubeconfig, "-n", "kube-system", "rollout", "status", @@ -3095,42 +2817,6 @@ func difference(left, right []string) []string { return out } -func appendUnique(values []string, additions ...string) []string { - seen := map[string]struct{}{} - for _, value := range values { - seen[value] = struct{}{} - } - for _, value := range additions { - if _, ok := seen[value]; ok { - continue - } - seen[value] = struct{}{} - values = append(values, value) - } - return values -} - -func cleanupCloudServersByID(ctx context.Context, cloudClient cloud.Client, instanceIDs []string) { - for _, instanceID := range instanceIDs { - if err := cloudClient.DeleteServer(ctx, instanceID); err != nil && !cloud.IsNotFound(err) { - _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API server cleanup warning for %s: %v\n", instanceID, err) - continue - } - deadline := time.Now().Add(10 * time.Minute) - for time.Now().Before(deadline) { - _, err := cloudClient.GetServer(ctx, instanceID) - if cloud.IsNotFound(err) { - break - } - if err != nil { - _, _ = fmt.Fprintf(GinkgoWriter, "STACKIT API server cleanup verification warning for %s: %v\n", instanceID, err) - break - } - time.Sleep(15 * time.Second) - } - } -} - func cleanupStackitVMFixture(clusterName, machineName, namespace string) { for _, args := range [][]string{ {"delete", "stackitmachine", machineName, "-n", namespace, "--ignore-not-found", "--wait=true", "--timeout=20m"}, diff --git a/util/conditions.go b/util/conditions.go deleted file mode 100644 index f60b2bf..0000000 --- a/util/conditions.go +++ /dev/null @@ -1,120 +0,0 @@ -/* -Copyright 2026. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 -*/ - -package util - -import ( - "errors" - "time" - - "k8s.io/apimachinery/pkg/api/meta" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - ctrl "sigs.k8s.io/controller-runtime" - - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" -) - -// SetCondition adds or updates a condition on conditions. -// -// The LastTransitionTime is only refreshed when the status actually changes, -// so callers can call this unconditionally on every reconcile. -func SetCondition( - conditions *[]metav1.Condition, - condType string, - status metav1.ConditionStatus, - reason, message string, - observedGeneration ...int64, -) { - now := metav1.Now() - var generation int64 - if len(observedGeneration) > 0 { - generation = observedGeneration[0] - } - for i, c := range *conditions { - if c.Type != condType { - continue - } - if c.Status == status && c.Reason == reason && c.Message == message && c.ObservedGeneration == generation { - return - } - (*conditions)[i].Status = status - (*conditions)[i].Reason = reason - (*conditions)[i].Message = message - (*conditions)[i].ObservedGeneration = generation - if c.Status != status { - (*conditions)[i].LastTransitionTime = now - } - return - } - *conditions = append(*conditions, metav1.Condition{ - Type: condType, - Status: status, - Reason: reason, - Message: message, - ObservedGeneration: generation, - LastTransitionTime: now, - }) -} - -func SetConditions( - conditions *[]metav1.Condition, - generation int64, - status metav1.ConditionStatus, - reason, message string, - conditionTypes ...string, -) { - for _, conditionType := range conditionTypes { - meta.SetStatusCondition(conditions, metav1.Condition{ - Type: conditionType, - Status: status, - Reason: reason, - Message: message, - ObservedGeneration: generation, - }) - } -} - -// CredentialFailureResult records the failure and decides how to retry. -// -// Invalid credentials need an operator to fix the Secret, so they requeue on a -// slow timer rather than returning an error and spinning through the controller -// backoff. The reconcile reads the Secret again, which is what picks up the fix. -func CredentialFailureResult( - conditions *[]metav1.Condition, - generation int64, - err error, - requeueAfter time.Duration, - conditionTypes ...string, -) (ctrl.Result, error) { - SetConditions(conditions, generation, metav1.ConditionFalse, "CredentialsInvalid", err.Error(), conditionTypes...) - if cloud.IsUnauthorized(err) || cloud.IsInvalidInput(err) || errors.Is(err, ErrCredentialsInvalid) { - return ctrl.Result{RequeueAfter: requeueAfter}, nil - } - return ctrl.Result{}, err -} - -func CloudFailureResult( - conditions *[]metav1.Condition, - generation int64, - reason string, - err error, - requeueAfter time.Duration, - returnError bool, - conditionTypes ...string, -) (ctrl.Result, error) { - SetConditions(conditions, generation, metav1.ConditionFalse, reason, err.Error(), conditionTypes...) - if cloud.IsRetryable(err) { - return ctrl.Result{RequeueAfter: requeueAfter}, nil - } - if returnError { - return ctrl.Result{}, err - } - return ctrl.Result{}, nil -} diff --git a/util/reconcile.go b/util/reconcile.go index 6a8b4b4..84eff37 100644 --- a/util/reconcile.go +++ b/util/reconcile.go @@ -17,7 +17,6 @@ import ( "strings" corev1 "k8s.io/api/core/v1" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/utils/ptr" clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" @@ -49,14 +48,6 @@ func ReconciliationPaused(cluster *clusterv1.Cluster, obj client.Object) (bool, return true, strings.Join(reasons, ", ") } -func SetPausedCondition(conditions *[]metav1.Condition, generation int64, paused bool, message string) { - if paused { - SetConditions(conditions, generation, metav1.ConditionTrue, clusterv1.PausedReason, message, clusterv1.PausedCondition) - return - } - SetConditions(conditions, generation, metav1.ConditionFalse, clusterv1.NotPausedReason, "", clusterv1.PausedCondition) -} - func BuildCloudClient( ctx context.Context, k8sClient client.Client, diff --git a/webhook/v1alpha1/validation_helpers.go b/webhook/v1alpha1/validation_helpers.go index d6bd2ce..aa42584 100644 --- a/webhook/v1alpha1/validation_helpers.go +++ b/webhook/v1alpha1/validation_helpers.go @@ -31,7 +31,6 @@ import ( clusterv1 "sigs.k8s.io/cluster-api/api/core/v1beta2" infrav1 "github.com/stackitcloud/cluster-api-provider-stackit/api/v1alpha1" - "github.com/stackitcloud/cluster-api-provider-stackit/cloud" ) const ( @@ -192,12 +191,8 @@ func validateBastionCloudInitRef(ref infrav1.StackitBastionCloudInitRef, fldPath func validateStackitMachineSpec(spec infrav1.StackitMachineSpec, fldPath *field.Path, allowProviderID bool) field.ErrorList { var allErrs field.ErrorList - if spec.ProviderID != nil { - if !allowProviderID { - allErrs = append(allErrs, field.Forbidden(fldPath.Child("providerID"), "providerID is generated per machine and must not be set in a template")) - } else if _, _, _, err := cloud.ParseProviderID(*spec.ProviderID); err != nil { - allErrs = append(allErrs, field.Invalid(fldPath.Child("providerID"), *spec.ProviderID, "must use STACKIT providerID format stackit://")) - } + if spec.ProviderID != nil && !allowProviderID { + allErrs = append(allErrs, field.Forbidden(fldPath.Child("providerID"), "providerID is generated per machine and must not be set in a template")) } allErrs = append(allErrs, validateRequiredPattern(spec.ImageID, uuidPattern, fldPath.Child("imageID"), "must be a STACKIT image UUID")...) diff --git a/webhook/v1alpha1/webhook_validation_test.go b/webhook/v1alpha1/webhook_validation_test.go index a3fa936..36febcf 100644 --- a/webhook/v1alpha1/webhook_validation_test.go +++ b/webhook/v1alpha1/webhook_validation_test.go @@ -162,15 +162,6 @@ var _ = Describe("STACKIT admission webhooks", func() { Expect(err).NotTo(HaveOccurred()) }) - It("rejects invalid providerID", func() { - machine := validStackitMachine("invalid-providerid") - providerID := "stackit://" - machine.Spec.ProviderID = &providerID - - _, err := validator.ValidateCreate(ctx, machine) - expectInvalidField(err, "spec.providerID") - }) - It("defaults machine root volume deleteOnTermination idempotently", func() { machine := validStackitMachine("default-machine")