Fix errors in ingress package (only non-test files)

Author: fischerman

cmd/application-load-balancer-controller-manager/main.go

@@ -250,7 +250,7 @@ func main() {
 	}
 	// Create an ALB client
 	fmt.Printf("Create ALB client\n")
-	albClient, err := albclient.NewClient(sdkClient)
+	albClient, err := albclient.NewApplicationLoadBalancerClient(sdkClient)
 	if err != nil {
 		setupLog.Error(err, "unable to create ALB client", "controller", "IngressClass")
 		os.Exit(1)

pkg/alb/ingress/alb_spec.go

@@ -79,10 +79,10 @@ func (r *IngressClassReconciler) albSpecFromIngress(
 
 	alb := &albsdk.CreateLoadBalancerPayload{
 		Options: &albsdk.LoadBalancerOptions{},
-		Networks: &[]albsdk.Network{
+		Networks: []albsdk.Network{
 			{
 				NetworkId: networkID,
-				Role:      albsdk.NETWORKROLE_LISTENERS_AND_TARGETS.Ptr(),
+				Role:      ptr.To("ROLE_LISTENERS_AND_TARGETS"),
 			},
 		},
 	}
@@ -207,7 +207,7 @@ func (r *IngressClassReconciler) albSpecFromIngress(
 		rulesCopy := hostToRules[host]
 		httpHosts = append(httpHosts, albsdk.HostConfig{
 			Host:  ptr.To(host),
-			Rules: &rulesCopy,
+			Rules: rulesCopy,
 		})
 	}
 
@@ -217,24 +217,24 @@ func (r *IngressClassReconciler) albSpecFromIngress(
 	listeners := []albsdk.Listener{
 		{
 			Name:     ptr.To("http"),
-			Port:     ptr.To(int64(80)),
-			Protocol: albsdk.LISTENERPROTOCOL_HTTP.Ptr(),
+			Port:     ptr.To(int32(80)),
+			Protocol: ptr.To("PROTOCOL_HTTP"),
 			Http: &albsdk.ProtocolOptionsHTTP{
-				Hosts: &httpHosts,
+				Hosts: httpHosts,
 			},
 		},
 	}
 	if len(allCertificateIDs) > 0 {
 		listeners = append(listeners, albsdk.Listener{
 			Name:     ptr.To("https"),
-			Port:     ptr.To(int64(443)),
-			Protocol: albsdk.LISTENERPROTOCOL_HTTPS.Ptr(),
+			Port:     ptr.To(int32(443)),
+			Protocol: ptr.To("PROTOCOL_HTTPS"),
 			Http: &albsdk.ProtocolOptionsHTTP{
-				Hosts: &httpHosts,
+				Hosts: httpHosts,
 			},
 			Https: &albsdk.ProtocolOptionsHTTPS{
 				CertificateConfig: &albsdk.CertificateConfig{
-					CertificateIds: &allCertificateIDs,
+					CertificateIds: allCertificateIDs,
 				},
 			},
 		})
@@ -247,8 +247,8 @@ func (r *IngressClassReconciler) albSpecFromIngress(
 	}
 
 	alb.Name = ptr.To(getAlbName(ingressClass))
-	alb.Listeners = &listeners
-	alb.TargetPools = &targetPools
+	alb.Listeners = listeners
+	alb.TargetPools = targetPools
 
 	return alb, nil
 }
@@ -328,7 +328,7 @@ func (r *IngressClassReconciler) cleanupCerts(ctx context.Context, ingressClass
 	if certificatesList == nil || certificatesList.Items == nil {
 		return nil // No certificates to clean up
 	}
-	for _, cert := range *certificatesList.Items {
+	for _, cert := range certificatesList.Items {
 		certID := *cert.Id
 		certName := *cert.Name
 
@@ -406,9 +406,9 @@ func addTargetPool(
 	}
 	*targetPools = append(*targetPools, albsdk.TargetPool{
 		Name:       ptr.To(targetPoolName),
-		TargetPort: ptr.To(int64(nodePort)),
+		TargetPort: ptr.To(int32(nodePort)),
 		TlsConfig:  tlsConfig,
-		Targets:    &targets,
+		Targets:    targets,
 	})
 }
 

pkg/alb/ingress/ingressclass_controller.go

@@ -34,7 +34,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 
-	albclient "github.com/stackitcloud/cloud-provider-stackit/pkg/stackit"
+	"github.com/stackitcloud/cloud-provider-stackit/pkg/stackit"
 	albsdk "github.com/stackitcloud/stackit-sdk-go/services/alb/v2api"
 )
 
@@ -48,8 +48,8 @@ const (
 // IngressClassReconciler reconciles a IngressClass object
 type IngressClassReconciler struct {
 	client.Client
-	ALBClient         albclient.Client
-	CertificateClient certificateclient.Client
+	ALBClient         stackit.ApplicationLoadBalancerClient
+	CertificateClient stackit.CertificatesClient
 	Scheme            *runtime.Scheme
 	ProjectID         string
 	NetworkID         string
@@ -190,7 +190,7 @@ func (r *IngressClassReconciler) handleIngressClassWithIngresses(
 
 	// Create ALB if it doesn't exist
 	alb, err := r.ALBClient.GetLoadBalancer(ctx, r.ProjectID, r.Region, getAlbName(ingressClass))
-	if errors.Is(err, albclient.ErrorNotFound) {
+	if errors.Is(err, stackit.ErrorNotFound) {
 		_, err := r.ALBClient.CreateLoadBalancer(ctx, r.ProjectID, r.Region, albPayload)
 		if err != nil {
 			return ctrl.Result{}, fmt.Errorf("failed to create load balancer: %w", err)
@@ -232,7 +232,7 @@ func (r *IngressClassReconciler) updateStatus(ctx context.Context, ingresses []*
 		return ctrl.Result{}, fmt.Errorf("failed to get load balancer: %w", err)
 	}
 
-	if *alb.Status != albclient.LBStatusReady {
+	if *alb.Status != stackit.LBStatusReady {
 		// ALB is not yet ready, requeue
 		return ctrl.Result{RequeueAfter: 10 * time.Second}, nil
 	}
@@ -324,13 +324,13 @@ func (r *IngressClassReconciler) handleIngressClassDeletion(
 
 // detectChange checks if there is any difference between the current and desired ALB configuration.
 func detectChange(alb *albsdk.LoadBalancer, albPayload *albsdk.CreateLoadBalancerPayload) bool {
-	if len(*alb.Listeners) != len(*albPayload.Listeners) {
+	if len(alb.Listeners) != len(albPayload.Listeners) {
 		return true
 	}
 
-	for i := range *alb.Listeners {
-		albListener := (*alb.Listeners)[i]
-		payloadListener := (*albPayload.Listeners)[i]
+	for i := range alb.Listeners {
+		albListener := (alb.Listeners)[i]
+		payloadListener := (albPayload.Listeners)[i]
 
 		if ptr.Deref(albListener.Protocol, "") != ptr.Deref(payloadListener.Protocol, "") ||
 			ptr.Deref(albListener.Port, 0) != ptr.Deref(payloadListener.Port, 0) {
@@ -342,25 +342,25 @@ func detectChange(alb *albsdk.LoadBalancer, albPayload *albsdk.CreateLoadBalance
 			albHosts := albListener.Http.Hosts
 			payloadHosts := payloadListener.Http.Hosts
 
-			if len(ptr.Deref(albHosts, nil)) != len(ptr.Deref(payloadHosts, nil)) {
+			if len(albHosts) != len(payloadHosts) {
 				return true
 			}
 
-			for j := range *albHosts {
-				albHost := (*albHosts)[j]
-				payloadHost := (*payloadHosts)[j]
+			for j := range albHosts {
+				albHost := albHosts[j]
+				payloadHost := payloadHosts[j]
 
 				if ptr.Deref(albHost.Host, "") != ptr.Deref(payloadHost.Host, "") {
 					return true
 				}
 
-				if len(ptr.Deref(albHost.Rules, nil)) != len(ptr.Deref(payloadHost.Rules, nil)) {
+				if len(albHost.Rules) != len(payloadHost.Rules) {
 					return true
 				}
 
-				for k := range *albHost.Rules {
-					albRule := (*albHost.Rules)[k]
-					payloadRule := (*payloadHost.Rules)[k]
+				for k := range albHost.Rules {
+					albRule := albHost.Rules[k]
+					payloadRule := payloadHost.Rules[k]
 
 					if albRule.Path != nil || payloadRule.Path != nil {
 						if albRule.Path == nil || payloadRule.Path == nil {
@@ -384,7 +384,7 @@ func detectChange(alb *albsdk.LoadBalancer, albPayload *albsdk.CreateLoadBalance
 		if albListener.Https != nil && payloadListener.Https != nil {
 			a := albListener.Https.CertificateConfig
 			b := payloadListener.Https.CertificateConfig
-			if len(ptr.Deref(a.CertificateIds, nil)) != len(ptr.Deref(b.CertificateIds, nil)) {
+			if len(a.CertificateIds) != len(b.CertificateIds) {
 				return true
 			}
 		} else if albListener.Https != nil || payloadListener.Https != nil {
@@ -394,19 +394,19 @@ func detectChange(alb *albsdk.LoadBalancer, albPayload *albsdk.CreateLoadBalance
 	}
 
 	// TargetPools comparison
-	if len(*alb.TargetPools) != len(*albPayload.TargetPools) {
+	if len(alb.TargetPools) != len(albPayload.TargetPools) {
 		return true
 	}
-	for i := range *alb.TargetPools {
-		a := (*alb.TargetPools)[i]
-		b := (*albPayload.TargetPools)[i]
+	for i := range alb.TargetPools {
+		a := alb.TargetPools[i]
+		b := albPayload.TargetPools[i]
 
 		if ptr.Deref(a.Name, "") != ptr.Deref(b.Name, "") ||
 			ptr.Deref(a.TargetPort, 0) != ptr.Deref(b.TargetPort, 0) {
 			return true
 		}
 
-		if len(ptr.Deref(a.Targets, nil)) != len(ptr.Deref(b.Targets, nil)) {
+		if len(a.Targets) != len(b.Targets) {
 			return true
 		}
 

pkg/stackit/applicationloadbalancer.go

@@ -21,7 +21,7 @@ const (
 	ProjectStatusDisabled ProjectStatus = "STATUS_DISABLED"
 )
 
-type Client interface {
+type ApplicationLoadBalancerClient interface {
 	GetLoadBalancer(ctx context.Context, projectID, region, name string) (*albsdk.LoadBalancer, error)
 	DeleteLoadBalancer(ctx context.Context, projectID, region, name string) error
 	CreateLoadBalancer(ctx context.Context, projectID, region string, albsdk *albsdk.CreateLoadBalancerPayload) (*albsdk.LoadBalancer, error)
@@ -34,17 +34,17 @@ type Client interface {
 	DeleteCredentials(ctx context.Context, projectID, region, credentialRef string) error
 }
 
-type client struct {
+type applicationLoadBalancerClient struct {
 	client *albsdk.APIClient
 }
 
-var _ Client = (*client)(nil)
+var _ ApplicationLoadBalancerClient = (*applicationLoadBalancerClient)(nil)
 
-func NewClient(cl *albsdk.APIClient) (Client, error) {
-	return &client{client: cl}, nil
+func NewApplicationLoadBalancerClient(cl *albsdk.APIClient) (ApplicationLoadBalancerClient, error) {
+	return &applicationLoadBalancerClient{client: cl}, nil
 }
 
-func (cl client) GetLoadBalancer(ctx context.Context, projectID, region, name string) (*albsdk.LoadBalancer, error) {
+func (cl applicationLoadBalancerClient) GetLoadBalancer(ctx context.Context, projectID, region, name string) (*albsdk.LoadBalancer, error) {
 	lb, err := cl.client.DefaultAPI.GetLoadBalancer(ctx, projectID, region, name).Execute()
 	if isOpenAPINotFound(err) {
 		return lb, ErrorNotFound
@@ -53,32 +53,32 @@ func (cl client) GetLoadBalancer(ctx context.Context, projectID, region, name st
 }
 
 // DeleteLoadBalancer returns no error if the load balancer doesn't exist.
-func (cl client) DeleteLoadBalancer(ctx context.Context, projectID, region, name string) error {
+func (cl applicationLoadBalancerClient) DeleteLoadBalancer(ctx context.Context, projectID, region, name string) error {
 	_, err := cl.client.DefaultAPI.DeleteLoadBalancer(ctx, projectID, region, name).Execute()
 	return err
 }
 
 // CreateLoadBalancer returns ErrorNotFound if the project is not enabled.
-func (cl client) CreateLoadBalancer(ctx context.Context, projectID, region string, create *albsdk.CreateLoadBalancerPayload) (*albsdk.LoadBalancer, error) {
+func (cl applicationLoadBalancerClient) CreateLoadBalancer(ctx context.Context, projectID, region string, create *albsdk.CreateLoadBalancerPayload) (*albsdk.LoadBalancer, error) {
 	lb, err := cl.client.DefaultAPI.CreateLoadBalancer(ctx, projectID, region).CreateLoadBalancerPayload(*create).XRequestID(uuid.NewString()).Execute()
 	if isOpenAPINotFound(err) {
 		return lb, ErrorNotFound
 	}
 	return lb, err
 }
 
-func (cl client) UpdateLoadBalancer(ctx context.Context, projectID, region, name string, update *albsdk.UpdateLoadBalancerPayload) (
+func (cl applicationLoadBalancerClient) UpdateLoadBalancer(ctx context.Context, projectID, region, name string, update *albsdk.UpdateLoadBalancerPayload) (
 	*albsdk.LoadBalancer, error,
 ) {
 	return cl.client.DefaultAPI.UpdateLoadBalancer(ctx, projectID, region, name).UpdateLoadBalancerPayload(*update).Execute()
 }
 
-func (cl client) UpdateTargetPool(ctx context.Context, projectID, region, name, targetPoolName string, payload albsdk.UpdateTargetPoolPayload) error {
+func (cl applicationLoadBalancerClient) UpdateTargetPool(ctx context.Context, projectID, region, name, targetPoolName string, payload albsdk.UpdateTargetPoolPayload) error {
 	_, err := cl.client.DefaultAPI.UpdateTargetPool(ctx, projectID, region, name, targetPoolName).UpdateTargetPoolPayload(payload).Execute()
 	return err
 }
 
-func (cl client) CreateCredentials(
+func (cl applicationLoadBalancerClient) CreateCredentials(
 	ctx context.Context,
 	projectID string,
 	region string,
@@ -87,23 +87,23 @@ func (cl client) CreateCredentials(
 	return cl.client.DefaultAPI.CreateCredentials(ctx, projectID, region).CreateCredentialsPayload(payload).XRequestID(uuid.NewString()).Execute()
 }
 
-func (cl client) ListCredentials(ctx context.Context, projectID, region string) (*albsdk.ListCredentialsResponse, error) {
+func (cl applicationLoadBalancerClient) ListCredentials(ctx context.Context, projectID, region string) (*albsdk.ListCredentialsResponse, error) {
 	return cl.client.DefaultAPI.ListCredentials(ctx, projectID, region).Execute()
 }
 
-func (cl client) GetCredentials(ctx context.Context, projectID, region, credentialsRef string) (*albsdk.GetCredentialsResponse, error) {
+func (cl applicationLoadBalancerClient) GetCredentials(ctx context.Context, projectID, region, credentialsRef string) (*albsdk.GetCredentialsResponse, error) {
 	return cl.client.DefaultAPI.GetCredentials(ctx, projectID, region, credentialsRef).Execute()
 }
 
-func (cl client) UpdateCredentials(ctx context.Context, projectID, region, credentialsRef string, payload albsdk.UpdateCredentialsPayload) error {
+func (cl applicationLoadBalancerClient) UpdateCredentials(ctx context.Context, projectID, region, credentialsRef string, payload albsdk.UpdateCredentialsPayload) error {
 	_, err := cl.client.DefaultAPI.UpdateCredentials(ctx, projectID, region, credentialsRef).UpdateCredentialsPayload(payload).Execute()
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
-func (cl client) DeleteCredentials(ctx context.Context, projectID, region, credentialsRef string) error {
+func (cl applicationLoadBalancerClient) DeleteCredentials(ctx context.Context, projectID, region, credentialsRef string) error {
 	_, err := cl.client.DefaultAPI.DeleteCredentials(ctx, projectID, region, credentialsRef).Execute()
 	if err != nil {
 		return err