diff --git a/CHANGELOG.md b/CHANGELOG.md index 90cf30520..0a66204c2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,7 @@ nav_order: 1 - Add `backup_hour` and `backup_minute` to `redis_user_config` and `valkey_user_config` - Add user configuration options for `external_s3`, `external_clickhouse` and `external_mysql` integration endpoint types - Use `ServiceGet` from the code-generated client +- Use the code-generated client to manage `aiven_service_integration` and `aiven_service_integration_endpoint` - Use Go 1.23 ## [4.24.0] - 2024-08-21 diff --git a/go.mod b/go.mod index 9d2630fce..1345f4c64 100644 --- a/go.mod +++ b/go.mod @@ -16,6 +16,7 @@ require ( github.com/hashicorp/terraform-plugin-mux v0.16.0 github.com/hashicorp/terraform-plugin-sdk/v2 v2.34.0 github.com/kelseyhightower/envconfig v1.4.0 + github.com/rs/zerolog v1.33.0 github.com/samber/lo v1.47.0 github.com/stoewer/go-strcase v1.3.0 github.com/stretchr/testify v1.9.0 @@ -38,7 +39,6 @@ require ( github.com/google/uuid v1.6.0 // indirect github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect github.com/hashicorp/go-retryablehttp v0.7.7 // indirect - github.com/rs/zerolog v1.33.0 // indirect github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 // indirect diff --git a/internal/sdkprovider/service/serviceintegration/service_integration.go b/internal/sdkprovider/service/serviceintegration/service_integration.go index 180ab2076..bc0d7fe3e 100644 --- a/internal/sdkprovider/service/serviceintegration/service_integration.go +++ b/internal/sdkprovider/service/serviceintegration/service_integration.go @@ -8,8 +8,8 @@ import ( "time" "github.com/aiven/aiven-go-client/v2" + avngen "github.com/aiven/go-client-codegen" codegenintegrations "github.com/aiven/go-client-codegen/handler/serviceintegration" - "github.com/hashicorp/terraform-plugin-sdk/v2/diag" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/retry" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" @@ -83,10 +83,10 @@ func aivenServiceIntegrationSchema() map[string]*schema.Schema { func ResourceServiceIntegration() *schema.Resource { return &schema.Resource{ Description: "Creates and manages an Aiven [service integration](https://aiven.io/docs/platform/concepts/service-integration).", - CreateContext: resourceServiceIntegrationCreate, - ReadContext: resourceServiceIntegrationRead, - UpdateContext: resourceServiceIntegrationUpdate, - DeleteContext: resourceServiceIntegrationDelete, + CreateContext: common.WithGenClient(resourceServiceIntegrationCreate), + ReadContext: common.WithGenClient(resourceServiceIntegrationRead), + UpdateContext: common.WithGenClient(resourceServiceIntegrationUpdate), + DeleteContext: common.WithGenClient(resourceServiceIntegrationDelete), Importer: &schema.ResourceImporter{ StateContext: schema.ImportStatePassthroughContext, }, @@ -109,9 +109,7 @@ func plainEndpointID(fullEndpointID *string) *string { return &endpointID } -func resourceServiceIntegrationCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func resourceServiceIntegrationCreate(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName := d.Get("project").(string) integrationType := d.Get("integration_type").(string) @@ -120,77 +118,75 @@ func resourceServiceIntegrationCreate(ctx context.Context, d *schema.ResourceDat // for now we support to seemlessly import preexisting 'read_replica' service integrations in the resource create // all other integrations should be imported using `terraform import` if integrationType == "read_replica" { - if preexisting, err := resourceServiceIntegrationCheckForPreexistingResource(ctx, d, m); err != nil { - return diag.Errorf("unable to search for possible preexisting 'read_replica' service integration: %s", err) + if preexisting, err := resourceServiceIntegrationCheckForPreexistingResource(ctx, d, client); err != nil { + return fmt.Errorf("unable to search for possible preexisting 'read_replica' service integration: %w", err) } else if preexisting != nil { - d.SetId(schemautil.BuildResourceID(projectName, preexisting.ServiceIntegrationID)) - return resourceServiceIntegrationRead(ctx, d, m) + d.SetId(schemautil.BuildResourceID(projectName, preexisting.ServiceIntegrationId)) + return resourceServiceIntegrationRead(ctx, d, client) } } - req := aiven.CreateServiceIntegrationRequest{ - DestinationEndpointID: plainEndpointID(schemautil.OptionalStringPointer(d, "destination_endpoint_id")), - DestinationService: schemautil.OptionalStringPointer(d, "destination_service_name"), - IntegrationType: integrationType, - SourceEndpointID: plainEndpointID(schemautil.OptionalStringPointer(d, "source_endpoint_id")), - SourceService: schemautil.OptionalStringPointer(d, "source_service_name"), + req := &codegenintegrations.ServiceIntegrationCreateIn{ + DestEndpointId: plainEndpointID(schemautil.OptionalStringPointer(d, "destination_endpoint_id")), + DestService: schemautil.OptionalStringPointer(d, "destination_service_name"), + IntegrationType: codegenintegrations.IntegrationType(integrationType), + SourceEndpointId: plainEndpointID(schemautil.OptionalStringPointer(d, "source_endpoint_id")), + SourceService: schemautil.OptionalStringPointer(d, "source_service_name"), } uc, err := converters.Expand(converters.ServiceIntegrationUserConfig, integrationType, d) if err != nil { - return diag.FromErr(err) + return err } - req.UserConfig = uc + if uc != nil { + req.UserConfig = &uc + } - res, err := client.ServiceIntegrations.Create(ctx, projectName, req) + res, err := client.ServiceIntegrationCreate(ctx, projectName, req) if err != nil { - return diag.Errorf("error creating service integration: %s", err) + return fmt.Errorf("error creating service integration: %w", err) } - d.SetId(schemautil.BuildResourceID(projectName, res.ServiceIntegrationID)) + d.SetId(schemautil.BuildResourceID(projectName, res.ServiceIntegrationId)) - if err = resourceServiceIntegrationWaitUntilActive(ctx, d, m, d.Timeout(schema.TimeoutCreate)); err != nil { - return diag.Errorf("unable to wait for service integration to become active: %s", err) + if err = resourceServiceIntegrationWaitUntilActive(ctx, d, client, d.Timeout(schema.TimeoutCreate)); err != nil { + return fmt.Errorf("unable to wait for service integration to become active: %w", err) } - return resourceServiceIntegrationRead(ctx, d, m) + return resourceServiceIntegrationRead(ctx, d, client) } -func resourceServiceIntegrationRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func resourceServiceIntegrationRead(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName, integrationID, err := schemautil.SplitResourceID2(d.Id()) if err != nil { - return diag.FromErr(err) + return err } - res, err := client.ServiceIntegrations.Get(ctx, projectName, integrationID) + res, err := client.ServiceIntegrationGet(ctx, projectName, integrationID) if err != nil { err = schemautil.ResourceReadHandleNotFound(err, d) if err != nil { - return diag.Errorf("cannot get service integration: %s; id: %s", err, integrationID) + return fmt.Errorf("cannot get service integration: %w; id: %s", err, integrationID) } return nil } if err = resourceServiceIntegrationCopyAPIResponseToTerraform(d, res, projectName); err != nil { - return diag.Errorf("cannot copy api response into terraform schema: %s", err) + return fmt.Errorf("cannot copy api response into terraform schema: %w", err) } return nil } -func resourceServiceIntegrationUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func resourceServiceIntegrationUpdate(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName, integrationID, err := schemautil.SplitResourceID2(d.Id()) if err != nil { - return diag.FromErr(err) + return err } integrationType := d.Get("integration_type").(string) userConfig, err := converters.Expand(converters.ServiceIntegrationUserConfig, integrationType, d) if err != nil { - return diag.FromErr(err) + return err } if userConfig == nil { @@ -198,75 +194,69 @@ func resourceServiceIntegrationUpdate(ctx context.Context, d *schema.ResourceDat userConfig = make(map[string]interface{}) } - _, err = client.ServiceIntegrations.Update( + _, err = client.ServiceIntegrationUpdate( ctx, projectName, integrationID, - aiven.UpdateServiceIntegrationRequest{ + &codegenintegrations.ServiceIntegrationUpdateIn{ UserConfig: userConfig, }, ) if err != nil { - return diag.Errorf("unable to update service integration: %s", err) + return fmt.Errorf("unable to update service integration: %w", err) } - if err = resourceServiceIntegrationWaitUntilActive(ctx, d, m, d.Timeout(schema.TimeoutUpdate)); err != nil { - return diag.Errorf("unable to wait for service integration to become active: %s", err) + if err = resourceServiceIntegrationWaitUntilActive(ctx, d, client, d.Timeout(schema.TimeoutUpdate)); err != nil { + return fmt.Errorf("unable to wait for service integration to become active: %w", err) } - return resourceServiceIntegrationRead(ctx, d, m) + return resourceServiceIntegrationRead(ctx, d, client) } -func resourceServiceIntegrationDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func resourceServiceIntegrationDelete(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName, integrationID, err := schemautil.SplitResourceID2(d.Id()) if err != nil { - return diag.FromErr(err) + return err } - err = client.ServiceIntegrations.Delete(ctx, projectName, integrationID) + err = client.ServiceIntegrationDelete(ctx, projectName, integrationID) if common.IsCritical(err) { - return diag.Errorf("cannot delete service integration: %s", err) + return fmt.Errorf("cannot delete service integration: %w", err) } return nil } -func resourceServiceIntegrationCheckForPreexistingResource(ctx context.Context, d *schema.ResourceData, m interface{}) (*aiven.ServiceIntegration, error) { - client := m.(*aiven.Client) - +func resourceServiceIntegrationCheckForPreexistingResource(ctx context.Context, d *schema.ResourceData, client avngen.Client) (*codegenintegrations.ServiceIntegrationOut, error) { projectName := d.Get("project").(string) integrationType := d.Get("integration_type").(string) sourceServiceName := d.Get("source_service_name").(string) destinationServiceName := d.Get("destination_service_name").(string) - integrations, err := client.ServiceIntegrations.List(ctx, projectName, sourceServiceName) + integrations, err := client.ServiceIntegrationList(ctx, projectName, sourceServiceName) if common.IsCritical(err) { return nil, fmt.Errorf("unable to get list of service integrations: %w", err) } for i := range integrations { integration := integrations[i] - if integration.SourceService == nil || integration.DestinationService == nil || integration.ServiceIntegrationID == "" { + if integration.SourceService == "" || integration.DestService == nil || integration.ServiceIntegrationId == "" { continue } if integration.IntegrationType == integrationType && - *integration.SourceService == sourceServiceName && - *integration.DestinationService == destinationServiceName { - return integration, nil + integration.SourceService == sourceServiceName && + *integration.DestService == destinationServiceName { + return &integration, nil } } return nil, nil } -func resourceServiceIntegrationWaitUntilActive(ctx context.Context, d *schema.ResourceData, m interface{}, timeout time.Duration) error { +func resourceServiceIntegrationWaitUntilActive(ctx context.Context, d *schema.ResourceData, client avngen.Client, timeout time.Duration) error { const ( active = "ACTIVE" notActive = "NOTACTIVE" ) - client := m.(*aiven.Client) - projectName, integrationID, err := schemautil.SplitResourceID2(d.Id()) if err != nil { return err @@ -278,7 +268,7 @@ func resourceServiceIntegrationWaitUntilActive(ctx context.Context, d *schema.Re Refresh: func() (interface{}, string, error) { log.Println("[DEBUG] Service Integration: waiting until active") - ii, err := client.ServiceIntegrations.Get(ctx, projectName, integrationID) + ii, err := client.ServiceIntegrationGet(ctx, projectName, integrationID) if err != nil { // Sometimes Aiven API retrieves 404 error even when a successful service integration is created if aiven.IsNotFound(err) { @@ -292,8 +282,8 @@ func resourceServiceIntegrationWaitUntilActive(ctx context.Context, d *schema.Re return nil, notActive, nil } - if ii.IntegrationType == "kafka_connect" && ii.DestinationService != nil { - if _, err := client.KafkaConnectors.List(ctx, projectName, *ii.DestinationService); err != nil { + if ii.IntegrationType == "kafka_connect" && ii.DestService != nil { + if _, err := client.ServiceKafkaConnectList(ctx, projectName, *ii.DestService); err != nil { log.Println("[DEBUG] Service Integration: error listing kafka connectors: ", err) return nil, notActive, nil } @@ -313,32 +303,32 @@ func resourceServiceIntegrationWaitUntilActive(ctx context.Context, d *schema.Re func resourceServiceIntegrationCopyAPIResponseToTerraform( d *schema.ResourceData, - res *aiven.ServiceIntegration, + res *codegenintegrations.ServiceIntegrationGetOut, project string, ) error { if err := d.Set("project", project); err != nil { return err } - if res.DestinationEndpointID != nil { - if err := d.Set("destination_endpoint_id", schemautil.BuildResourceID(project, *res.DestinationEndpointID)); err != nil { + if res.DestEndpointId != nil { + if err := d.Set("destination_endpoint_id", schemautil.BuildResourceID(project, *res.DestEndpointId)); err != nil { return err } - } else if res.DestinationService != nil { - if err := d.Set("destination_service_name", *res.DestinationService); err != nil { + } else if res.DestService != nil { + if err := d.Set("destination_service_name", *res.DestService); err != nil { return err } } - if res.SourceEndpointID != nil { - if err := d.Set("source_endpoint_id", schemautil.BuildResourceID(project, *res.SourceEndpointID)); err != nil { + if res.SourceEndpointId != nil { + if err := d.Set("source_endpoint_id", schemautil.BuildResourceID(project, *res.SourceEndpointId)); err != nil { return err } - } else if res.SourceService != nil { - if err := d.Set("source_service_name", *res.SourceService); err != nil { + } else if res.SourceService != "" { + if err := d.Set("source_service_name", res.SourceService); err != nil { return err } } - if err := d.Set("integration_id", res.ServiceIntegrationID); err != nil { + if err := d.Set("integration_id", res.ServiceIntegrationId); err != nil { return err } integrationType := res.IntegrationType diff --git a/internal/sdkprovider/service/serviceintegration/service_integration_data_source.go b/internal/sdkprovider/service/serviceintegration/service_integration_data_source.go index f8e9e901d..ace37367a 100644 --- a/internal/sdkprovider/service/serviceintegration/service_integration_data_source.go +++ b/internal/sdkprovider/service/serviceintegration/service_integration_data_source.go @@ -2,50 +2,49 @@ package serviceintegration import ( "context" + "fmt" - "github.com/aiven/aiven-go-client/v2" - "github.com/hashicorp/terraform-plugin-sdk/v2/diag" + avngen "github.com/aiven/go-client-codegen" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + "github.com/aiven/terraform-provider-aiven/internal/common" "github.com/aiven/terraform-provider-aiven/internal/schemautil" ) func DatasourceServiceIntegration() *schema.Resource { return &schema.Resource{ - ReadContext: datasourceServiceIntegrationRead, + ReadContext: common.WithGenClient(datasourceServiceIntegrationRead), Description: "Gets information about an Aiven service integration.", Schema: schemautil.ResourceSchemaAsDatasourceSchema(aivenServiceIntegrationSchema(), "project", "integration_type", "source_service_name", "destination_service_name"), } } -func datasourceServiceIntegrationRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func datasourceServiceIntegrationRead(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName := d.Get("project").(string) integrationType := d.Get("integration_type").(string) sourceServiceName := d.Get("source_service_name").(string) destinationServiceName := d.Get("destination_service_name").(string) - integrations, err := client.ServiceIntegrations.List(ctx, projectName, sourceServiceName) + integrations, err := client.ServiceIntegrationList(ctx, projectName, sourceServiceName) if err != nil { - return diag.Errorf("unable to list integrations for %s/%s: %s", projectName, sourceServiceName, err) + return fmt.Errorf("unable to list integrations for %s/%s: %w", projectName, sourceServiceName, err) } for _, i := range integrations { - if i.SourceService == nil || i.DestinationService == nil { + if i.SourceService == "" || i.DestService == nil { continue } if i.IntegrationType == integrationType && - *i.SourceService == sourceServiceName && - *i.DestinationService == destinationServiceName { + i.SourceService == sourceServiceName && + *i.DestService == destinationServiceName { - d.SetId(schemautil.BuildResourceID(projectName, i.ServiceIntegrationID)) - return resourceServiceIntegrationRead(ctx, d, m) + d.SetId(schemautil.BuildResourceID(projectName, i.ServiceIntegrationId)) + return resourceServiceIntegrationRead(ctx, d, client) } } - return diag.Errorf("common integration %s/%s/%s/%s not found", + return fmt.Errorf("common integration %s/%s/%s/%s not found", projectName, integrationType, sourceServiceName, destinationServiceName) } diff --git a/internal/sdkprovider/service/serviceintegration/service_integration_endpoint.go b/internal/sdkprovider/service/serviceintegration/service_integration_endpoint.go index b7ec9bc88..47065c901 100644 --- a/internal/sdkprovider/service/serviceintegration/service_integration_endpoint.go +++ b/internal/sdkprovider/service/serviceintegration/service_integration_endpoint.go @@ -5,9 +5,8 @@ import ( "fmt" "slices" - "github.com/aiven/aiven-go-client/v2" + avngen "github.com/aiven/go-client-codegen" codegenintegrations "github.com/aiven/go-client-codegen/handler/serviceintegration" - "github.com/hashicorp/terraform-plugin-sdk/v2/diag" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" @@ -18,8 +17,8 @@ import ( "github.com/aiven/terraform-provider-aiven/internal/sdkprovider/userconfig/serviceintegrationendpoint" ) -func hasEndpointConfig(kind string) bool { - return slices.Contains(serviceintegrationendpoint.UserConfigTypes(), kind) +func hasEndpointConfig[T string | codegenintegrations.EndpointType](kind T) bool { + return slices.Contains(serviceintegrationendpoint.UserConfigTypes(), string(kind)) } func aivenServiceIntegrationEndpointSchema() map[string]*schema.Schema { @@ -62,10 +61,10 @@ func aivenServiceIntegrationEndpointSchema() map[string]*schema.Schema { func ResourceServiceIntegrationEndpoint() *schema.Resource { return &schema.Resource{ Description: "The Service Integration Endpoint resource allows the creation and management of Aiven Service Integration Endpoints.", - CreateContext: resourceServiceIntegrationEndpointCreate, - ReadContext: resourceServiceIntegrationEndpointRead, - UpdateContext: resourceServiceIntegrationEndpointUpdate, - DeleteContext: resourceServiceIntegrationEndpointDelete, + CreateContext: common.WithGenClient(resourceServiceIntegrationEndpointCreate), + ReadContext: common.WithGenClient(resourceServiceIntegrationEndpointRead), + UpdateContext: common.WithGenClient(resourceServiceIntegrationEndpointUpdate), + DeleteContext: common.WithGenClient(resourceServiceIntegrationEndpointDelete), Importer: &schema.ResourceImporter{ StateContext: schema.ImportStatePassthroughContext, }, @@ -77,101 +76,92 @@ func ResourceServiceIntegrationEndpoint() *schema.Resource { } } -func resourceServiceIntegrationEndpointCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) +func resourceServiceIntegrationEndpointCreate(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName := d.Get("project").(string) endpointType := d.Get("endpoint_type").(string) - req := aiven.CreateServiceIntegrationEndpointRequest{ + req := &codegenintegrations.ServiceIntegrationEndpointCreateIn{ EndpointName: d.Get("endpoint_name").(string), - EndpointType: endpointType, + EndpointType: codegenintegrations.EndpointType(endpointType), UserConfig: make(map[string]interface{}), } if hasEndpointConfig(endpointType) { uc, err := converters.Expand(converters.ServiceIntegrationEndpointUserConfig, endpointType, d) if err != nil { - return diag.FromErr(err) + return err } if uc != nil { req.UserConfig = uc } } - endpoint, err := client.ServiceIntegrationEndpoints.Create(ctx, projectName, req) - + endpoint, err := client.ServiceIntegrationEndpointCreate(ctx, projectName, req) if err != nil { - return diag.FromErr(err) + return err } - d.SetId(schemautil.BuildResourceID(projectName, endpoint.EndpointID)) - - return resourceServiceIntegrationEndpointRead(ctx, d, m) + d.SetId(schemautil.BuildResourceID(projectName, endpoint.EndpointId)) + return resourceServiceIntegrationEndpointRead(ctx, d, client) } -func resourceServiceIntegrationEndpointRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func resourceServiceIntegrationEndpointRead(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName, endpointID, err := schemautil.SplitResourceID2(d.Id()) if err != nil { - return diag.FromErr(err) + return err } - endpoint, err := client.ServiceIntegrationEndpoints.Get(ctx, projectName, endpointID) + endpoint, err := client.ServiceIntegrationEndpointGet(ctx, projectName, endpointID, codegenintegrations.ServiceIntegrationEndpointGetIncludeSecrets(true)) if err != nil { - return diag.FromErr(schemautil.ResourceReadHandleNotFound(err, d)) + return schemautil.ResourceReadHandleNotFound(err, d) } err = copyServiceIntegrationEndpointPropertiesFromAPIResponseToTerraform(d, endpoint, projectName) if err != nil { - return diag.FromErr(err) + return err } return nil } -func resourceServiceIntegrationEndpointUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func resourceServiceIntegrationEndpointUpdate(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName, endpointID, err := schemautil.SplitResourceID2(d.Id()) if err != nil { - return diag.FromErr(err) + return err } endpointType := d.Get("endpoint_type").(string) - req := aiven.UpdateServiceIntegrationEndpointRequest{ + req := &codegenintegrations.ServiceIntegrationEndpointUpdateIn{ UserConfig: make(map[string]interface{}), } if hasEndpointConfig(endpointType) { uc, err := converters.Expand(converters.ServiceIntegrationEndpointUserConfig, endpointType, d) if err != nil { - return diag.FromErr(err) + return err } if uc != nil { req.UserConfig = uc } } - _, err = client.ServiceIntegrationEndpoints.Update(ctx, projectName, endpointID, req) + _, err = client.ServiceIntegrationEndpointUpdate(ctx, projectName, endpointID, req) if err != nil { - return diag.FromErr(err) + return err } - return resourceServiceIntegrationEndpointRead(ctx, d, m) + return resourceServiceIntegrationEndpointRead(ctx, d, client) } -func resourceServiceIntegrationEndpointDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func resourceServiceIntegrationEndpointDelete(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName, endpointID, err := schemautil.SplitResourceID2(d.Id()) if err != nil { - return diag.FromErr(err) + return err } - err = client.ServiceIntegrationEndpoints.Delete(ctx, projectName, endpointID) + err = client.ServiceIntegrationEndpointDelete(ctx, projectName, endpointID) if common.IsCritical(err) { - return diag.FromErr(err) + return err } return nil @@ -179,7 +169,7 @@ func resourceServiceIntegrationEndpointDelete(ctx context.Context, d *schema.Res func copyServiceIntegrationEndpointPropertiesFromAPIResponseToTerraform( d *schema.ResourceData, - endpoint *aiven.ServiceIntegrationEndpoint, + endpoint *codegenintegrations.ServiceIntegrationEndpointGetOut, project string, ) error { if err := d.Set("project", project); err != nil { @@ -188,7 +178,7 @@ func copyServiceIntegrationEndpointPropertiesFromAPIResponseToTerraform( if err := d.Set("endpoint_name", endpoint.EndpointName); err != nil { return err } - endpointType := endpoint.EndpointType + endpointType := string(endpoint.EndpointType) if err := d.Set("endpoint_type", endpointType); err != nil { return err } diff --git a/internal/sdkprovider/service/serviceintegration/service_integration_endpoint_data_source.go b/internal/sdkprovider/service/serviceintegration/service_integration_endpoint_data_source.go index fee48a421..b156bc863 100644 --- a/internal/sdkprovider/service/serviceintegration/service_integration_endpoint_data_source.go +++ b/internal/sdkprovider/service/serviceintegration/service_integration_endpoint_data_source.go @@ -2,40 +2,39 @@ package serviceintegration import ( "context" + "fmt" - "github.com/aiven/aiven-go-client/v2" - "github.com/hashicorp/terraform-plugin-sdk/v2/diag" + avngen "github.com/aiven/go-client-codegen" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + "github.com/aiven/terraform-provider-aiven/internal/common" "github.com/aiven/terraform-provider-aiven/internal/schemautil" ) func DatasourceServiceIntegrationEndpoint() *schema.Resource { return &schema.Resource{ - ReadContext: datasourceServiceIntegrationEndpointRead, + ReadContext: common.WithGenClient(datasourceServiceIntegrationEndpointRead), Description: "The Service Integration Endpoint data source provides information about the existing Aiven Service Integration Endpoint.", Schema: schemautil.ResourceSchemaAsDatasourceSchema(aivenServiceIntegrationEndpointSchema(), "project", "endpoint_name"), } } -func datasourceServiceIntegrationEndpointRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics { - client := m.(*aiven.Client) - +func datasourceServiceIntegrationEndpointRead(ctx context.Context, d *schema.ResourceData, client avngen.Client) error { projectName := d.Get("project").(string) endpointName := d.Get("endpoint_name").(string) - endpoints, err := client.ServiceIntegrationEndpoints.List(ctx, projectName) + endpoints, err := client.ServiceIntegrationEndpointList(ctx, projectName) if err != nil { - return diag.FromErr(err) + return err } for _, endpoint := range endpoints { if endpoint.EndpointName == endpointName { - d.SetId(schemautil.BuildResourceID(projectName, endpoint.EndpointID)) - return resourceServiceIntegrationEndpointRead(ctx, d, m) + d.SetId(schemautil.BuildResourceID(projectName, endpoint.EndpointId)) + return resourceServiceIntegrationEndpointRead(ctx, d, client) } } - return diag.Errorf("endpoint \"%s\" not found", endpointName) + return fmt.Errorf("endpoint \"%s\" not found", endpointName) }