Refactor to use OpenAPI SDK

Author: assafad1

.github/workflows/e2e-tests.yaml

@@ -23,6 +23,7 @@ jobs:
       CORALOGIX_REGION: ${{ secrets.CORALOGIX_REGION }}
       CORALOGIX_API_KEY: ${{ secrets.CORALOGIX_API_KEY }}
       SCOPE_RECONCILE_INTERVAL_SECONDS: 30
+      CONNECTOR_RECONCILE_INTERVAL_SECONDS: 30
       AWS_REGION: ${{ secrets.AWS_REGION }}
       LOGS_BUCKET: ${{ secrets.LOGS_BUCKET }}
       METRICS_BUCKET: ${{ secrets.METRICS_BUCKET }}

.github/workflows/helm-e2e-tests.yaml

@@ -50,7 +50,8 @@ jobs:
             --set coralogixOperator.image.repository="${{ env.IMG_REPO }}" \
             --set coralogixOperator.image.tag="${{ env.IMG_TAG }}" \
             --set coralogixOperator.region="${{ secrets.CORALOGIX_REGION }}" \
-            --set coralogixOperator.reconcileIntervalSeconds.scope=30
+            --set coralogixOperator.reconcileIntervalSeconds.scope=30 \
+            --set coralogixOperator.reconcileIntervalSeconds.connector=30
       - name: Run e2e Tests
         run: |
           make e2e-tests

.github/workflows/upgrade-test.yaml

@@ -66,7 +66,8 @@ jobs:
             --set coralogixOperator.image.repository="${{ env.IMG_REPO }}" \
             --set coralogixOperator.image.tag="${{ env.IMG_TAG }}" \
             --set coralogixOperator.region="${{ secrets.CORALOGIX_REGION }}" \
-            --set coralogixOperator.reconcileIntervalSeconds.scope=30
+            --set coralogixOperator.reconcileIntervalSeconds.scope=30 \
+            --set coralogixOperator.reconcileIntervalSeconds.connector=30
       - name: Run e2e Tests
         run: |
           make e2e-tests

.golangci.yaml

@@ -10,7 +10,6 @@ linters:
     - asasalint
     - asciicheck
     - bidichk
-    - bodyclose
     - copyloopvar
     - dogsled
     - errcheck

api/coralogix/v1alpha1/apikey_types.go

@@ -15,10 +15,8 @@
 package v1alpha1
 
 import (
+	apikeys "github.com/coralogix/coralogix-management-sdk/go/openapi/gen/api_keys_service"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/utils/ptr"
-
-	cxsdk "github.com/coralogix/coralogix-management-sdk/go"
 )
 
 // ApiKeySpec defines the desired state of a Coralogix ApiKey.
@@ -114,33 +112,31 @@ type ApiKeyList struct {
 	Items           []ApiKey `json:"items"`
 }
 
-func (s *ApiKeySpec) ExtractCreateApiKeyRequest() *cxsdk.CreateAPIKeyRequest {
-	owner := &cxsdk.Owner{}
+func (s *ApiKeySpec) ExtractCreateApiKeyRequest() *apikeys.CreateApiKeyRequest {
+	owner := apikeys.Owner{}
 	if s.Owner.UserId != nil {
-		owner.Owner = &cxsdk.OwnerUserID{UserId: *s.Owner.UserId}
+		owner.OwnerOneOf = &apikeys.OwnerOneOf{UserId: s.Owner.UserId}
 	}
 	if s.Owner.TeamId != nil {
-		owner.Owner = &cxsdk.OwnerTeamID{TeamId: *s.Owner.TeamId}
+		owner.OwnerOneOf1 = &apikeys.OwnerOneOf1{TeamId: apikeys.PtrInt64(int64(*s.Owner.TeamId))}
 	}
 
-	return &cxsdk.CreateAPIKeyRequest{
+	return &apikeys.CreateApiKeyRequest{
 		Name:  s.Name,
 		Owner: owner,
-		KeyPermissions: &cxsdk.APIKeyPermissions{
+		KeyPermissions: apikeys.CreateApiKeyRequestKeyPermissions{
 			Presets:     s.Presets,
 			Permissions: s.Permissions,
 		},
-		Hashed: false,
 	}
 }
 
-func (s *ApiKeySpec) ExtractUpdateApiKeyRequest(id string) *cxsdk.UpdateAPIKeyRequest {
-	return &cxsdk.UpdateAPIKeyRequest{
-		KeyId:       id,
-		NewName:     ptr.To(s.Name),
-		IsActive:    ptr.To(s.Active),
-		Presets:     ptr.To(cxsdk.APIKeyPresetsUpdate{Presets: s.Presets}),
-		Permissions: ptr.To(cxsdk.APIKeyPermissionsUpdate{Permissions: s.Permissions}),
+func (s *ApiKeySpec) ExtractUpdateApiKeyRequest() *apikeys.UpdateApiKeyRequest {
+	return &apikeys.UpdateApiKeyRequest{
+		NewName:     apikeys.PtrString(s.Name),
+		IsActive:    apikeys.PtrBool(s.Active),
+		Presets:     &apikeys.Presets{Presets: s.Presets},
+		Permissions: &apikeys.UpdateApiKeyRequestPermissions{Permissions: s.Permissions},
 	}
 }
 

api/coralogix/v1alpha1/connector_types.go

@@ -19,7 +19,7 @@ import (
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
-	cxsdk "github.com/coralogix/coralogix-management-sdk/go"
+	connectors "github.com/coralogix/coralogix-management-sdk/go/openapi/gen/connectors_service"
 )
 
 // ConnectorSpec defines the desired state of Connector.
@@ -105,51 +105,29 @@ func (c *Connector) HasIDInStatus() bool {
 }
 
 var (
-	schemaToProtoConnectorType = map[string]cxsdk.ConnectorType{
-		"slack":        cxsdk.ConnectorTypeSlack,
-		"genericHttps": cxsdk.ConnectorTypeGenericHTTPS,
-		"pagerDuty":    cxsdk.ConnectorTypePagerDuty,
+	schemaToOpenApiConnectorType = map[string]connectors.ConnectorType{
+		"slack":        connectors.CONNECTORTYPE_SLACK,
+		"genericHttps": connectors.CONNECTORTYPE_GENERIC_HTTPS,
+		"pagerDuty":    connectors.CONNECTORTYPE_PAGERDUTY,
 	}
-	schemaToProtoEntityType = map[string]cxsdk.NotificationsEntityType{
-		"alerts": cxsdk.NotificationsEntityTypeAlerts,
+	schemaToOpenApiEntityType = map[string]*connectors.NotificationCenterEntityType{
+		"alerts": connectors.NOTIFICATIONCENTERENTITYTYPE_ALERTS.Ptr(),
 	}
 )
 
-func (c *Connector) ExtractCreateConnectorRequest() (*cxsdk.CreateConnectorRequest, error) {
-	connector, err := c.ExtractConnector()
-	if err != nil {
-		return nil, fmt.Errorf("failed to extract connector: %w", err)
-	}
-	return &cxsdk.CreateConnectorRequest{
-		Connector: connector,
-	}, nil
-}
-
-func (c *Connector) ExtractUpdateConnectorRequest() (*cxsdk.ReplaceConnectorRequest, error) {
-	connector, err := c.ExtractConnector()
-	if err != nil {
-		return nil, fmt.Errorf("failed to extract connector: %w", err)
-	}
-
-	connector.Id = c.Status.Id
-	return &cxsdk.ReplaceConnectorRequest{
-		Connector: connector,
-	}, nil
-}
-
-func (c *Connector) ExtractConnector() (*cxsdk.Connector, error) {
-	connector := &cxsdk.Connector{
+func (c *Connector) ExtractConnector() (*connectors.Connector1, error) {
+	connector := &connectors.Connector1{
 		Name:        c.Spec.Name,
-		Description: c.Spec.Description,
+		Description: connectors.PtrString(c.Spec.Description),
 	}
 
-	connectorType, ok := schemaToProtoConnectorType[c.Spec.Type]
+	connectorType, ok := schemaToOpenApiConnectorType[c.Spec.Type]
 	if !ok {
 		return nil, fmt.Errorf("unsupported connector type: %s", c.Spec.Type)
 	}
 	connector.Type = connectorType
 
-	connector.ConnectorConfig = &cxsdk.ConnectorConfig{
+	connector.ConnectorConfig = &connectors.ConnectorConfig{
 		Fields: ExtractConnectorConfigFields(c.Spec.ConnectorConfig.Fields),
 	}
 
@@ -162,27 +140,27 @@ func (c *Connector) ExtractConnector() (*cxsdk.Connector, error) {
 	return connector, nil
 }
 
-func ExtractConnectorConfigFields(fields []ConnectorConfigField) []*cxsdk.ConnectorConfigField {
-	var result []*cxsdk.ConnectorConfigField
+func ExtractConnectorConfigFields(fields []ConnectorConfigField) []connectors.NotificationCenterConnectorConfigField {
+	var result []connectors.NotificationCenterConnectorConfigField
 	for _, field := range fields {
-		result = append(result, &cxsdk.ConnectorConfigField{
-			FieldName: field.FieldName,
-			Value:     field.Value,
+		result = append(result, connectors.NotificationCenterConnectorConfigField{
+			FieldName: connectors.PtrString(field.FieldName),
+			Value:     connectors.PtrString(field.Value),
 		})
 	}
 
 	return result
 }
 
-func ExtractEntityTypeConfigOverrides(overrides []EntityTypeConfigOverrides) ([]*cxsdk.EntityTypeConfigOverrides, error) {
-	var result []*cxsdk.EntityTypeConfigOverrides
+func ExtractEntityTypeConfigOverrides(overrides []EntityTypeConfigOverrides) ([]connectors.EntityTypeConfigOverrides, error) {
+	var result []connectors.EntityTypeConfigOverrides
 	for _, override := range overrides {
-		entityType, ok := schemaToProtoEntityType[override.EntityType]
+		entityType, ok := schemaToOpenApiEntityType[override.EntityType]
 		if !ok {
 			return nil, fmt.Errorf("invalid entity type %s", override.EntityType)
 		}
 
-		entityTypeConfigOverrides := &cxsdk.EntityTypeConfigOverrides{
+		entityTypeConfigOverrides := connectors.EntityTypeConfigOverrides{
 			EntityType: entityType,
 		}
 
@@ -193,12 +171,12 @@ func ExtractEntityTypeConfigOverrides(overrides []EntityTypeConfigOverrides) ([]
 	return result, nil
 }
 
-func ExtractConfigOverridesFields(fields []TemplatedConnectorConfigField) []*cxsdk.TemplatedConnectorConfigField {
-	var result []*cxsdk.TemplatedConnectorConfigField
+func ExtractConfigOverridesFields(fields []TemplatedConnectorConfigField) []connectors.TemplatedConnectorConfigField {
+	var result []connectors.TemplatedConnectorConfigField
 	for _, field := range fields {
-		result = append(result, &cxsdk.TemplatedConnectorConfigField{
-			FieldName: field.FieldName,
-			Template:  field.Template,
+		result = append(result, connectors.TemplatedConnectorConfigField{
+			FieldName: connectors.PtrString(field.FieldName),
+			Template:  connectors.PtrString(field.Template),
 		})
 	}
 

api/coralogix/v1alpha1/globalrouter_types.go

@@ -23,7 +23,7 @@ import (
 	"k8s.io/utils/ptr"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
-	cxsdk "github.com/coralogix/coralogix-management-sdk/go"
+	globalrouters "github.com/coralogix/coralogix-management-sdk/go/openapi/gen/global_routers_service"
 
 	"github.com/coralogix/coralogix-operator/internal/config"
 )
@@ -92,17 +92,13 @@ type NCRef struct {
 	ResourceRef *ResourceRef `json:"resourceRef,omitempty"`
 }
 
-func (g *GlobalRouter) ExtractCreateOrReplaceGlobalRouterRequest(ctx context.Context) (*cxsdk.CreateOrReplaceGlobalRouterRequest, error) {
-	router, err := g.ExtractGlobalRouter(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to extract global-router: %w", err)
+var (
+	schemaToOpenApiRoutersEntityType = map[string]globalrouters.NotificationCenterEntityType{
+		"alerts": globalrouters.NOTIFICATIONCENTERENTITYTYPE_ALERTS,
 	}
+)
 
-	router.Id = ptr.To("router_default")
-	return &cxsdk.CreateOrReplaceGlobalRouterRequest{Router: router}, nil
-}
-
-func (g *GlobalRouter) ExtractGlobalRouter(ctx context.Context) (*cxsdk.GlobalRouter, error) {
+func (g *GlobalRouter) ExtractGlobalRouter(ctx context.Context) (*globalrouters.GlobalRouter, error) {
 	fallback, err := extractRoutingTargets(ctx, g.Namespace, g.Spec.Fallback)
 	if err != nil {
 		return nil, err
@@ -113,24 +109,26 @@ func (g *GlobalRouter) ExtractGlobalRouter(ctx context.Context) (*cxsdk.GlobalRo
 		return nil, err
 	}
 
-	return &cxsdk.GlobalRouter{
+	return &globalrouters.GlobalRouter{
+		Id:          ptr.To("router_default"),
+		EntityType:  schemaToOpenApiRoutersEntityType[g.Spec.EntityType],
 		Name:        g.Spec.Name,
-		Description: g.Spec.Description,
+		Description: globalrouters.PtrString(g.Spec.Description),
 		Fallback:    fallback,
 		Rules:       rules,
 	}, nil
 }
 
-func extractRoutingRules(ctx context.Context, namespace string, rules []RoutingRule) ([]*cxsdk.RoutingRule, error) {
-	var result []*cxsdk.RoutingRule
+func extractRoutingRules(ctx context.Context, namespace string, rules []RoutingRule) ([]globalrouters.RoutingRule, error) {
+	var result []globalrouters.RoutingRule
 	var errs error
 	for _, rule := range rules {
 		routingRule, err := extractRoutingRule(ctx, namespace, rule)
 		if err != nil {
 			errs = errors.Join(errs, err)
 			continue
 		}
-		result = append(result, routingRule)
+		result = append(result, *routingRule)
 	}
 
 	if errs != nil {
@@ -140,29 +138,29 @@ func extractRoutingRules(ctx context.Context, namespace string, rules []RoutingR
 	return result, nil
 }
 
-func extractRoutingRule(ctx context.Context, namespace string, rule RoutingRule) (*cxsdk.RoutingRule, error) {
+func extractRoutingRule(ctx context.Context, namespace string, rule RoutingRule) (*globalrouters.RoutingRule, error) {
 	targets, err := extractRoutingTargets(ctx, namespace, rule.Targets)
 	if err != nil {
 		return nil, err
 	}
 
-	return &cxsdk.RoutingRule{
+	return &globalrouters.RoutingRule{
 		Name:      ptr.To(rule.Name),
 		Condition: rule.Condition,
 		Targets:   targets,
 	}, nil
 }
 
-func extractRoutingTargets(ctx context.Context, namespace string, targets []RoutingTarget) ([]*cxsdk.RoutingTarget, error) {
-	var result []*cxsdk.RoutingTarget
+func extractRoutingTargets(ctx context.Context, namespace string, targets []RoutingTarget) ([]globalrouters.RoutingTarget, error) {
+	var result []globalrouters.RoutingTarget
 	var errs error
 	for _, target := range targets {
 		routingTarget, err := extractRoutingTarget(ctx, namespace, target)
 		if err != nil {
 			errs = errors.Join(errs, err)
 			continue
 		}
-		result = append(result, routingTarget)
+		result = append(result, *routingTarget)
 	}
 
 	if errs != nil {
@@ -172,7 +170,7 @@ func extractRoutingTargets(ctx context.Context, namespace string, targets []Rout
 	return result, nil
 }
 
-func extractRoutingTarget(ctx context.Context, namespace string, target RoutingTarget) (*cxsdk.RoutingTarget, error) {
+func extractRoutingTarget(ctx context.Context, namespace string, target RoutingTarget) (*globalrouters.RoutingTarget, error) {
 	connectorID, err := extractConnectorID(ctx, namespace, target.Connector)
 	if err != nil {
 		return nil, err
@@ -186,7 +184,7 @@ func extractRoutingTarget(ctx context.Context, namespace string, target RoutingT
 		}
 	}
 
-	return &cxsdk.RoutingTarget{
+	return &globalrouters.RoutingTarget{
 		ConnectorId: connectorID,
 		PresetId:    ptr.To(presetID),
 	}, nil