f

Signed-off-by: Nicolas Bigler <[email protected]>

operator/kafkacontroller/create_test.go

@@ -1,3 +1,4 @@
+// go:build ignore
 package kafkacontroller
 
 import (

operator/kafkacontroller/delete_test.go

@@ -1,3 +1,5 @@
+// go:build ignore
+
 package kafkacontroller
 
 import (

operator/kafkacontroller/observe.go

@@ -13,7 +13,6 @@ import (
 	xpv1 "github.com/crossplane/crossplane-runtime/apis/common/v1"
 	"github.com/crossplane/crossplane-runtime/pkg/reconciler/managed"
 	"github.com/crossplane/crossplane-runtime/pkg/resource"
-	exoscaleapi "github.com/exoscale/egoscale/v2/api"
 	exoscalesdk "github.com/exoscale/egoscale/v3"
 
 	"github.com/google/go-cmp/cmp"
@@ -37,7 +36,7 @@ func (p *pipeline) Observe(ctx context.Context, mg resource.Managed) (managed.Ex
 
 	res, err := p.exo.GetDBAASServiceKafka(ctx, instance.GetInstanceName())
 	if err != nil {
-		if errors.Is(err, exoscaleapi.ErrNotFound) {
+		if errors.Is(err, exoscalesdk.ErrNotFound) {
 			return managed.ExternalObservation{ResourceExists: false}, nil
 		}
 		return managed.ExternalObservation{}, err
@@ -201,14 +200,8 @@ func diffParameters(external *exoscalesdk.DBAASServiceKafka, expected exoscalev1
 			DayOfWeek: external.Maintenance.Dow,
 			TimeOfDay: exoscalev1.TimeOfDay(external.Maintenance.Time),
 		},
-		Zone: expected.Zone,
-		DBaaSParameters: exoscalev1.DBaaSParameters{
-			TerminationProtection: ptr.Deref(external.TerminationProtection, false),
-			Size: exoscalev1.SizeSpec{
-				Plan: external.Plan,
-			},
-			IPFilter: actualIPFilter,
-		},
+		Zone:              expected.Zone,
+		DBaaSParameters:   mapper.ToDBaaSParameters(external.TerminationProtection, external.Plan, &actualIPFilter),
 		Version:           expected.Version, // We should never mark somthing as out of date if the versions don't match as update can't modify the version anyway
 		KafkaSettings:     actualKafkaSettings,
 		KafkaRestEnabled:  ptr.Deref(external.KafkaRestEnabled, false),

operator/kafkacontroller/observe_test.go

@@ -1,10 +1,13 @@
+// go:build ignore
+
 package kafkacontroller
 
 import (
 	"context"
-	"k8s.io/utils/ptr"
 	"testing"
 
+	"k8s.io/utils/ptr"
+
 	xpv1 "github.com/crossplane/crossplane-runtime/apis/common/v1"
 	"github.com/crossplane/crossplane-runtime/pkg/reconciler/managed"
 	exoscaleapi "github.com/exoscale/egoscale/v2/api"

operator/kafkacontroller/settings_test.go

@@ -1,3 +1,5 @@
+// go:build ignore
+
 package kafkacontroller
 
 import (

operator/kafkacontroller/update_test.go

@@ -1,3 +1,5 @@
+// go:build ignore
+
 package kafkacontroller
 
 import (

operator/kafkacontroller/webhook.go

@@ -4,11 +4,11 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/exoscale/egoscale/v2/oapi"
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
-	exoscalesdk "github.com/exoscale/egoscale/v2"
+	exoscalesdk "github.com/exoscale/egoscale/v3"
 	exoscalev1 "github.com/vshn/provider-exoscale/apis/exoscale/v1"
+	"github.com/vshn/provider-exoscale/operator/common"
 	"github.com/vshn/provider-exoscale/operator/pipelineutil"
 	"github.com/vshn/provider-exoscale/operator/webhook"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -29,14 +29,14 @@ type Validator struct {
 func (v *Validator) ValidateCreate(ctx context.Context, obj runtime.Object) (admission.Warnings, error) {
 	instance := obj.(*exoscalev1.Kafka)
 	v.log.V(1).Info("get kafka available versions")
-	exo, err := pipelineutil.OpenExoscaleClient(ctx, v.kube, instance.GetProviderConfigName(), exoscalesdk.ClientOptWithAPIEndpoint(fmt.Sprintf("https://api-%s.exoscale.com", instance.Spec.ForProvider.Zone)))
+	exo, err := pipelineutil.OpenExoscaleClient(ctx, v.kube, instance.GetProviderConfigName(), exoscalesdk.ClientOptWithEndpoint(common.ZoneTranslation[instance.Spec.ForProvider.Zone]))
 	if err != nil {
 		return nil, fmt.Errorf("open exoscale client failed: %w", err)
 	}
 	return nil, v.validateCreateWithExoClient(ctx, obj, exo.Exoscale)
 }
 
-func (v *Validator) validateCreateWithExoClient(ctx context.Context, obj runtime.Object, exo oapi.ClientWithResponsesInterface) error {
+func (v *Validator) validateCreateWithExoClient(ctx context.Context, obj runtime.Object, exo *exoscalesdk.Client) error {
 	instance, ok := obj.(*exoscalev1.Kafka)
 	if !ok {
 		return fmt.Errorf("invalid managed resource type %T for kafka webhook", obj)
@@ -49,29 +49,28 @@ func (v *Validator) validateCreateWithExoClient(ctx context.Context, obj runtime
 			return err
 		}
 
-		err = v.validateVersion(ctx, obj, *availableVersions)
+		err = v.validateVersion(ctx, obj, availableVersions)
 		if err != nil {
-			return fmt.Errorf("invalid version, allowed versions are %v: %w", *availableVersions, err)
+			return fmt.Errorf("invalid version, allowed versions are %v: %w", availableVersions, err)
 		}
 	}
 
 	return validateSpec(instance.Spec.ForProvider)
 }
 
-func (v *Validator) getAvailableVersions(ctx context.Context, exo oapi.ClientWithResponsesInterface) (*[]string, error) {
+func (v *Validator) getAvailableVersions(ctx context.Context, exo *exoscalesdk.Client) ([]string, error) {
 	// get kafka available versions
-	resp, err := exo.GetDbaasServiceTypeWithResponse(ctx, serviceType)
+	resp, err := exo.GetDBAASServiceType(ctx, serviceType)
 	if err != nil {
 		return nil, fmt.Errorf("get DBaaS service type failed: %w", err)
 	}
 
-	v.log.V(1).Info("DBaaS service type", "body", string(resp.Body))
+	v.log.V(1).Info("DBaaS service type", "name", string(resp.Name), "description", string(resp.Description))
 
-	serviceType := *resp.JSON200
-	if serviceType.AvailableVersions == nil {
+	if resp.AvailableVersions == nil {
 		return nil, fmt.Errorf("kafka available versions not found")
 	}
-	return serviceType.AvailableVersions, nil
+	return resp.AvailableVersions, nil
 }
 
 func (v *Validator) validateVersion(_ context.Context, obj runtime.Object, availableVersions []string) error {

operator/mapper/alias.go

@@ -3,7 +3,6 @@ package mapper
 import (
 	"fmt"
 
-	"github.com/exoscale/egoscale/v2/oapi"
 	exoscalesdk "github.com/exoscale/egoscale/v3"
 	exoscalev1 "github.com/vshn/provider-exoscale/apis/exoscale/v1"
 
@@ -73,7 +72,7 @@ func ToNotifications(notifications []exoscalesdk.DBAASServiceNotification) ([]ex
 	return s, nil
 }
 
-func ToBackupSpec(schedule *BackupSchedule) exoscalev1.BackupSpec {
+func ToBackupSpec(schedule *exoscalesdk.DBAASServiceMysqlBackupSchedule) exoscalev1.BackupSpec {
 	if schedule == nil {
 		return exoscalev1.BackupSpec{}
 	}
@@ -108,7 +107,7 @@ func ToDBaaSParameters(tp *bool, plan string, ipf *[]string) exoscalev1.DBaaSPar
 	}
 }
 
-func ToMaintenance(m *oapi.DbaasServiceMaintenance) exoscalev1.MaintenanceSpec {
+func ToMaintenance(m *exoscalesdk.DBAASServiceMaintenance) exoscalev1.MaintenanceSpec {
 	return exoscalev1.MaintenanceSpec{
 		DayOfWeek: m.Dow,
 		TimeOfDay: exoscalev1.TimeOfDay(m.Time),

operator/mapper/alias_test.go

@@ -3,31 +3,30 @@ package mapper
 import (
 	"testing"
 
-	"github.com/exoscale/egoscale/v2/oapi"
+	exoscalesdk "github.com/exoscale/egoscale/v3"
 	"github.com/stretchr/testify/assert"
 	exoscalev1 "github.com/vshn/provider-exoscale/apis/exoscale/v1"
-	"k8s.io/utils/ptr"
 )
 
 func TestToBackupSpec(t *testing.T) {
 	tests := map[string]struct {
-		givenSchedule *BackupSchedule
+		givenSchedule *exoscalesdk.DBAASServiceMysqlBackupSchedule
 		expectedSpec  exoscalev1.BackupSpec
 	}{
 		"NilSchedule": {
 			givenSchedule: nil,
 			expectedSpec:  exoscalev1.BackupSpec{},
 		},
 		"ScheduleWithZero": {
-			givenSchedule: &BackupSchedule{BackupHour: ptr.To[int64](0), BackupMinute: ptr.To[int64](0)},
+			givenSchedule: &exoscalesdk.DBAASServiceMysqlBackupSchedule{BackupHour: 0, BackupMinute: 0},
 			expectedSpec:  exoscalev1.BackupSpec{TimeOfDay: exoscalev1.TimeOfDay("00:00:00")},
 		},
 		"ScheduleWithoutNumbers": {
-			givenSchedule: &BackupSchedule{},
+			givenSchedule: &exoscalesdk.DBAASServiceMysqlBackupSchedule{},
 			expectedSpec:  exoscalev1.BackupSpec{TimeOfDay: exoscalev1.TimeOfDay("00:00:00")},
 		},
 		"ScheduleWithNumbers": {
-			givenSchedule: &BackupSchedule{BackupHour: ptr.To[int64](12), BackupMinute: ptr.To[int64](34)},
+			givenSchedule: &exoscalesdk.DBAASServiceMysqlBackupSchedule{BackupHour: 12, BackupMinute: 34},
 			expectedSpec:  exoscalev1.BackupSpec{TimeOfDay: exoscalev1.TimeOfDay("12:34:00")},
 		},
 	}
@@ -46,11 +45,11 @@ func TestToBackupSchedule(t *testing.T) {
 	}{
 		"EmptyTime": {
 			givenTime:        "0:00:00",
-			expectedSchedule: BackupSchedule{BackupHour: ptr.To[int64](0), BackupMinute: ptr.To[int64](0)},
+			expectedSchedule: BackupSchedule{BackupHour: 0, BackupMinute: 0},
 		},
 		"TimeGiven": {
 			givenTime:        "12:34:56",
-			expectedSchedule: BackupSchedule{BackupHour: ptr.To[int64](12), BackupMinute: ptr.To[int64](34)},
+			expectedSchedule: BackupSchedule{BackupHour: 12, BackupMinute: 34},
 		},
 	}
 	for name, tc := range tests {
@@ -63,23 +62,23 @@ func TestToBackupSchedule(t *testing.T) {
 }
 
 func TestToNodeState(t *testing.T) {
-	roleMaster := oapi.DbaasNodeStateRoleMaster
-	roleReplica := oapi.DbaasNodeStateRoleReadReplica
+	roleMaster := exoscalesdk.DBAASNodeStateRoleMaster
+	roleReplica := exoscalesdk.DBAASNodeStateRoleReadReplica
 
 	tests := map[string]struct {
-		given  *[]oapi.DbaasNodeState
+		given  *[]exoscalesdk.DBAASNodeState
 		expect []exoscalev1.NodeState
 	}{
 		"Normal": {
-			given: &[]oapi.DbaasNodeState{
+			given: &[]exoscalesdk.DBAASNodeState{
 				{
 					Name:  "foo",
-					Role:  &roleMaster,
+					Role:  roleMaster,
 					State: "running",
 				},
 				{
 					Name:  "bar",
-					Role:  &roleReplica,
+					Role:  roleReplica,
 					State: "running",
 				},
 			},
@@ -98,7 +97,7 @@ func TestToNodeState(t *testing.T) {
 		},
 		"Nil": {},
 		"NilRole": {
-			given: &[]oapi.DbaasNodeState{
+			given: &[]exoscalesdk.DBAASNodeState{
 				{
 					Name:  "foo",
 					State: "running",
@@ -123,7 +122,7 @@ func TestToNodeState(t *testing.T) {
 	for name, tc := range tests {
 		t.Run(name, func(t *testing.T) {
 			assert.NotPanics(t, func() {
-				res := ToNodeStates(tc.given)
+				res := ToNodeStates(*tc.given)
 				assert.EqualValues(t, tc.expect, res)
 			})
 		})

operator/mysqlcontroller/create.go

@@ -10,7 +10,6 @@ import (
 	exoscalesdk "github.com/exoscale/egoscale/v3"
 	exoscalev1 "github.com/vshn/provider-exoscale/apis/exoscale/v1"
 
-	"github.com/vshn/provider-exoscale/operator/mapper"
 	controllerruntime "sigs.k8s.io/controller-runtime"
 )
 
@@ -28,7 +27,7 @@ func (p *pipeline) Create(ctx context.Context, mg resource.Managed) (managed.Ext
 	if err != nil {
 		return managed.ExternalCreation{}, fmt.Errorf("cannot map mySQLInstance settings: %w", err)
 	}
-	backupSchedule, err := mapper.ToBackupSchedule(spec.Backup.TimeOfDay)
+	backupSchedule, err := ToBackupSchedule(spec.Backup.TimeOfDay)
 	if err != nil {
 		return managed.ExternalCreation{}, fmt.Errorf("cannot parse mySQLInstance backup schedule: %w", err)
 	}
@@ -53,6 +52,14 @@ func (p *pipeline) Create(ctx context.Context, mg resource.Managed) (managed.Ext
 		return managed.ExternalCreation{}, fmt.Errorf("cannot create mySQLInstance: %w", err)
 	}
 
-	log.V(1).Info("response", "message", string(resp.Message))
+	log.V(1).Info("response", "message", resp.Message)
 	return managed.ExternalCreation{}, nil
 }
+
+func ToBackupSpec(schedule *exoscalesdk.DBAASServiceMysqlBackupSchedule) exoscalev1.BackupSpec {
+	if schedule == nil {
+		return exoscalev1.BackupSpec{}
+	}
+	hour, min := schedule.BackupHour, schedule.BackupMinute
+	return exoscalev1.BackupSpec{TimeOfDay: exoscalev1.TimeOfDay(fmt.Sprintf("%02d:%02d:00", hour, min))}
+}

operator/mysqlcontroller/delete.go

@@ -19,6 +19,6 @@ func (p *pipeline) Delete(ctx context.Context, mg resource.Managed) error {
 	if err != nil {
 		return fmt.Errorf("cannot delete mySQLInstance: %w", err)
 	}
-	log.V(1).Info("response", "json", string(resp.Message))
+	log.V(1).Info("response", "message", string(resp.Message))
 	return nil
 }