refactor file structure

Author: xoxys

go.mod

@@ -20,6 +20,7 @@ require (
 	github.com/stackitcloud/stackit-sdk-go/services/loadbalancer v1.15.1
 	github.com/stackitcloud/stackit-sdk-go/services/resourcemanager v0.24.2
 	github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.20.1
+	github.com/stackitcloud/stackit-sdk-go/services/serviceenablement v1.7.0
 	github.com/stackitcloud/stackit-sdk-go/services/ske v1.6.0
 	go.uber.org/mock v0.6.0
 	golang.org/x/sync v0.22.0
@@ -96,7 +97,6 @@ require (
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/prometheus/common v0.70.1 // indirect
 	github.com/prometheus/procfs v0.21.1 // indirect
-	github.com/stackitcloud/stackit-sdk-go/services/serviceenablement v1.7.0 // indirect
 	github.com/stoewer/go-strcase v1.3.1 // indirect
 	github.com/stretchr/objx v0.5.3 // indirect
 	github.com/x448/float16 v0.8.4 // indirect

test/kubetest2/bootstrap_csi.go

@@ -0,0 +1,15 @@
+package kubetest2
+
+import (
+	"context"
+
+	"k8s.io/klog/v2"
+)
+
+// ensureCSI deploys the STACKIT CSI driver into the freshly provisioned
+// cluster as the last bootstrap step. Not yet implemented; will install the
+// CSI Helm chart here.
+func (d *Deployer) ensureCSI(_ context.Context) error {
+	klog.Infof("CSI deployment not yet implemented, skipping")
+	return nil
+}

test/kubetest2/bootstrap_project.go

@@ -0,0 +1,153 @@
+package kubetest2
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+
+	oapierror "github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	resourcemanager "github.com/stackitcloud/stackit-sdk-go/services/resourcemanager/v0api"
+	serviceenablement "github.com/stackitcloud/stackit-sdk-go/services/serviceenablement/v2api"
+	"k8s.io/klog/v2"
+)
+
+type managedProject struct {
+	ContainerID string
+	ProjectID   string
+	Name        string
+	Labels      map[string]string
+}
+
+// ensureProject idempotently resolves (or creates) the managed STACKIT project
+// and enables the SKE service for it. Sets d.projectID on success.
+func (d *Deployer) ensureProject(ctx context.Context) error {
+	project, err := d.resolveManagedProject(ctx)
+	if err != nil {
+		return err
+	}
+	d.projectID = project.ProjectID
+
+	return d.ensureSKEServiceEnabled(ctx, project.ProjectID)
+}
+
+func (d *Deployer) findManagedProject(ctx context.Context) (*managedProject, error) {
+	projects, err := d.projectClient.ListProjects(ctx, d.parentContainerID)
+	if err != nil {
+		return nil, fmt.Errorf("list STACKIT projects under parent container %q: %w", d.parentContainerID, err)
+	}
+
+	matches := make([]managedProject, 0, 1)
+	for i := range projects {
+		project := &projects[i]
+		if !d.matchesManagedProject(project) {
+			continue
+		}
+		matches = append(matches, managedProject{
+			ContainerID: project.GetContainerId(),
+			ProjectID:   project.GetProjectId(),
+			Name:        project.GetName(),
+			Labels:      project.GetLabels(),
+		})
+	}
+
+	switch len(matches) {
+	case 0:
+		return nil, nil
+	case 1:
+		return &matches[0], nil
+	default:
+		return nil, fmt.Errorf(
+			"found %d managed STACKIT projects for run token %q under parent container %q",
+			len(matches),
+			d.runToken(),
+			d.parentContainerID,
+		)
+	}
+}
+
+func (d *Deployer) resolveManagedProject(ctx context.Context) (*managedProject, error) {
+	project, err := d.findManagedProject(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if project != nil {
+		klog.Infof("Reusing managed project=%q project_id=%q", project.Name, project.ProjectID)
+		return project, nil
+	}
+
+	klog.Infof("Creating managed project=%q under parent_container_id=%q", d.projectName(), d.parentContainerID)
+	createdProject, err := d.projectClient.CreateProject(
+		ctx,
+		d.parentContainerID,
+		d.projectName(),
+		d.projectMemberEmail,
+		d.managedProjectLabels(),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("create STACKIT project %q: %w", d.projectName(), err)
+	}
+
+	activeProject, err := d.projectClient.WaitForProjectActive(ctx, createdProject.GetContainerId())
+	if err != nil {
+		return nil, fmt.Errorf("wait for STACKIT project %q to become active: %w", createdProject.GetProjectId(), err)
+	}
+
+	return &managedProject{
+		ContainerID: activeProject.GetContainerId(),
+		ProjectID:   activeProject.GetProjectId(),
+		Name:        activeProject.GetName(),
+		Labels:      activeProject.GetLabels(),
+	}, nil
+}
+
+func (d *Deployer) managedProjectLabels() map[string]string {
+	return map[string]string{
+		projectLabelScopeKey:   projectLabelScopeValue,
+		projectLabelManagedKey: projectLabelManagedValue,
+		projectLabelRunIDKey:   d.runToken(),
+	}
+}
+
+func (d *Deployer) matchesManagedProject(project *resourcemanager.Project) bool {
+	if project.GetName() != d.projectName() {
+		return false
+	}
+	labels := project.GetLabels()
+	if labels == nil {
+		return false
+	}
+	return labels[projectLabelScopeKey] == projectLabelScopeValue &&
+		labels[projectLabelManagedKey] == projectLabelManagedValue &&
+		labels[projectLabelRunIDKey] == d.runToken()
+}
+
+// ensureSKEServiceEnabled idempotently enables the SKE (Kubernetes Engine)
+// service for the managed project and waits until it is enabled.
+func (d *Deployer) ensureSKEServiceEnabled(ctx context.Context, projectID string) error {
+	status, err := d.serviceEnablementClient.GetServiceStatus(ctx, d.region, projectID, skeServiceID)
+	if err != nil {
+		if !isNotFound(err) {
+			return fmt.Errorf("get SKE service status for project %q: %w", projectID, err)
+		}
+		klog.Infof("SKE service not yet enabled for project_id=%q", projectID)
+	} else if status.GetState() == serviceenablement.SERVICESTATUSSTATE_ENABLED {
+		klog.Infof("SKE service already enabled for project_id=%q", projectID)
+		return nil
+	} else {
+		klog.Infof("SKE service in state %q for project_id=%q, enabling", status.GetState(), projectID)
+	}
+
+	if err := d.serviceEnablementClient.EnableService(ctx, d.region, projectID, skeServiceID); err != nil {
+		return fmt.Errorf("enable SKE service for project %q: %w", projectID, err)
+	}
+	if err := d.serviceEnablementClient.WaitForServiceEnabled(ctx, d.region, projectID, skeServiceID); err != nil {
+		return fmt.Errorf("wait for SKE service enablement for project %q: %w", projectID, err)
+	}
+	return nil
+}
+
+func isNotFound(err error) bool {
+	var oapiErr *oapierror.GenericOpenAPIError
+	return errors.As(err, &oapiErr) && oapiErr.StatusCode == http.StatusNotFound
+}

test/kubetest2/bootstrap_project_test.go

@@ -0,0 +1,157 @@
+package kubetest2
+
+import (
+	"context"
+	"net/http"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	oapierror "github.com/stackitcloud/stackit-sdk-go/core/oapierror"
+	resourcemanager "github.com/stackitcloud/stackit-sdk-go/services/resourcemanager/v0api"
+	serviceenablement "github.com/stackitcloud/stackit-sdk-go/services/serviceenablement/v2api"
+)
+
+var _ = Describe("matchesManagedProject", func() {
+	It("matches a project with the expected name and labels", func() {
+		d := newTestDeployer()
+		project := projectFixture(d.projectName(), "project-1", "container-1", d.managedProjectLabels())
+		Expect(d.matchesManagedProject(project)).To(BeTrue())
+	})
+
+	It("rejects a project with a different name", func() {
+		d := newTestDeployer()
+		project := projectFixture("other-name", "project-1", "container-1", d.managedProjectLabels())
+		Expect(d.matchesManagedProject(project)).To(BeFalse())
+	})
+
+	It("rejects a project without labels", func() {
+		d := newTestDeployer()
+		project := projectFixture(d.projectName(), "project-1", "container-1", nil)
+		Expect(d.matchesManagedProject(project)).To(BeFalse())
+	})
+
+	DescribeTable("rejects a project with mismatched labels",
+		func(labels map[string]string) {
+			d := newTestDeployer()
+			project := projectFixture(d.projectName(), "project-1", "container-1", labels)
+			Expect(d.matchesManagedProject(project)).To(BeFalse())
+		},
+		Entry("wrong scope", map[string]string{
+			projectLabelScopeKey:   "PRIVATE",
+			projectLabelManagedKey: projectLabelManagedValue,
+			projectLabelRunIDKey:   runTokenForRun("run-123"),
+		}),
+		Entry("missing managed label", map[string]string{
+			projectLabelScopeKey: projectLabelScopeValue,
+			projectLabelRunIDKey: runTokenForRun("run-123"),
+		}),
+		Entry("wrong run id", map[string]string{
+			projectLabelScopeKey:   projectLabelScopeValue,
+			projectLabelManagedKey: projectLabelManagedValue,
+			projectLabelRunIDKey:   "deadbeef",
+		}),
+	)
+})
+
+var _ = Describe("resolveManagedProject", func() {
+	It("creates a project when missing", func() {
+		d := newTestDeployer()
+		projectClient := &fakeProjectClient{
+			createProjectResult: projectFixture(d.projectName(), "project-123", "container-123", d.managedProjectLabels()),
+			waitActiveResult:    projectResponseFixture(d.projectName(), "project-123", "container-123", d.managedProjectLabels()),
+		}
+		d.projectClient = projectClient
+
+		project, err := d.resolveManagedProject(context.Background())
+		Expect(err).NotTo(HaveOccurred())
+		Expect(project.ProjectID).To(Equal("project-123"))
+		Expect(projectClient.createCalls).To(Equal(1))
+		Expect(projectClient.waitActiveCalls).To(Equal(1))
+		Expect(projectClient.lastCreateParentContainerID).To(Equal(d.parentContainerID))
+		Expect(projectClient.lastCreateName).To(Equal(d.projectName()))
+		Expect(projectClient.lastCreateOwnerEmail).To(Equal(d.projectMemberEmail))
+		Expect(projectClient.lastCreateLabels).To(Equal(d.managedProjectLabels()))
+	})
+
+	It("errors on multiple matches", func() {
+		d := newTestDeployer()
+		d.projectClient = &fakeProjectClient{
+			listProjectsResult: []resourcemanager.Project{
+				*projectFixture(d.projectName(), "project-1", "container-1", d.managedProjectLabels()),
+				*projectFixture(d.projectName(), "project-2", "container-2", d.managedProjectLabels()),
+			},
+		}
+
+		_, err := d.findManagedProject(context.Background())
+		Expect(err).To(MatchError(ContainSubstring("found 2 managed STACKIT projects")))
+	})
+})
+
+var _ = Describe("ensureProject", func() {
+	It("resolves the managed project and enables the SKE service", func() {
+		d := newTestDeployer()
+		d.projectClient = &fakeProjectClient{
+			listProjectsResult: []resourcemanager.Project{
+				*projectFixture(d.projectName(), "project-123", "container-123", d.managedProjectLabels()),
+			},
+		}
+		serviceEnablementClient := &fakeServiceEnablementClient{getStatusResult: serviceenablement.NewServiceStatus()}
+		d.serviceEnablementClient = serviceEnablementClient
+
+		Expect(d.ensureProject(context.Background())).To(Succeed())
+		Expect(d.projectID).To(Equal("project-123"))
+		Expect(serviceEnablementClient.lastGetStatusProjectID).To(Equal("project-123"))
+		Expect(serviceEnablementClient.enableCalls).To(Equal(0))
+	})
+})
+
+var _ = Describe("ensureSKEServiceEnabled", func() {
+	It("skips when already enabled", func() {
+		d := newTestDeployer()
+		client := &fakeServiceEnablementClient{getStatusResult: serviceenablement.NewServiceStatus()}
+		d.serviceEnablementClient = client
+
+		Expect(d.ensureSKEServiceEnabled(context.Background(), "project-123")).To(Succeed())
+		Expect(client.enableCalls).To(Equal(0))
+		Expect(client.waitCalls).To(Equal(0))
+		Expect(client.lastGetStatusServiceID).To(Equal(skeServiceID))
+	})
+
+	It("enables when not found", func() {
+		d := newTestDeployer()
+		client := &fakeServiceEnablementClient{
+			getStatusErr: &oapierror.GenericOpenAPIError{StatusCode: http.StatusNotFound},
+		}
+		d.serviceEnablementClient = client
+
+		Expect(d.ensureSKEServiceEnabled(context.Background(), "project-123")).To(Succeed())
+		Expect(client.enableCalls).To(Equal(1))
+		Expect(client.waitCalls).To(Equal(1))
+		Expect(client.lastEnableProjectID).To(Equal("project-123"))
+		Expect(client.lastEnableServiceID).To(Equal(skeServiceID))
+	})
+
+	It("enables when disabled", func() {
+		d := newTestDeployer()
+		client := &fakeServiceEnablementClient{
+			getStatusResult: disabledServiceStatusFixture(),
+		}
+		d.serviceEnablementClient = client
+
+		Expect(d.ensureSKEServiceEnabled(context.Background(), "project-123")).To(Succeed())
+		Expect(client.enableCalls).To(Equal(1))
+		Expect(client.waitCalls).To(Equal(1))
+	})
+
+	It("fails on get status error", func() {
+		d := newTestDeployer()
+		client := &fakeServiceEnablementClient{
+			getStatusErr: &oapierror.GenericOpenAPIError{StatusCode: http.StatusForbidden},
+		}
+		d.serviceEnablementClient = client
+
+		err := d.ensureSKEServiceEnabled(context.Background(), "project-123")
+		Expect(err).To(HaveOccurred())
+		Expect(client.enableCalls).To(Equal(0))
+	})
+})