[AV-129295] Revert [AV-125341] Add private endpoint DNS (#568)

Author: toshikagarwal

.factory/skills/tf-examples-gen/SKILL.md

@@ -114,4 +114,4 @@ If there is no datasource to get a specific resource then skip this step.
 
 Fix errors until terraform validate passes.
 
-Do not run terraform init as tests will run against a dev build.
+Do not run terraform init as tests will run against a dev build.

internal/api/private_endpoints.go

@@ -4,16 +4,13 @@ package api
 type GetPrivateEndpointResponse struct {
 	// Id is the endpoint id.
 	Id string `json:"id"`
-
-	// Status is the endpoint status.  Possible values are failed, linked, pending, pendingAcceptance, rejected and unrecognized
+	// Status is the endpoint status.  Possible values are failed, linked, pending, pendingAcceptance, rejected and unrecognized.
 	Status string `json:"status"`
-
 	// ServiceName is the name of the endpoint service.
 	ServiceName string `json:"serviceName"`
 }
 
 // GetPrivateEndpointsResponse is a list of private endpoints.
 type GetPrivateEndpointsResponse struct {
-	PrivateEndpointDNS string                       `json:"privateEndpointDNS"`
-	Endpoints          []GetPrivateEndpointResponse `json:"endpoints"`
+	Endpoints []GetPrivateEndpointResponse `json:"endpoints"`
 }

internal/datasources/private_endpoints.go

@@ -91,17 +91,11 @@ func (p *PrivateEndpoints) Read(ctx context.Context, req datasource.ReadRequest,
 		return
 	}
 
-	state.PrivateEndpointDNS = types.StringValue(privateEndpointsResp.PrivateEndpointDNS)
-
 	for _, e := range privateEndpointsResp.Endpoints {
-		endpointData := providerschema.PrivateEndpointData{
-			Id:             types.StringValue(e.Id),
-			OrganizationId: types.StringValue(organizationId),
-			ProjectId:      types.StringValue(projectId),
-			ClusterId:      types.StringValue(clusterId),
-			Status:         types.StringValue(e.Status),
-			ServiceName:    types.StringValue(e.ServiceName),
-		}
+		endpointData := providerschema.PrivateEndpointData{}
+		endpointData.Id = types.StringValue(e.Id)
+		endpointData.Status = types.StringValue(e.Status)
+		endpointData.ServiceName = types.StringValue(e.ServiceName)
 		state.Data = append(state.Data, endpointData)
 	}
 

internal/datasources/private_endpoints_schema.go

@@ -15,15 +15,14 @@ func PrivateEndpointsSchema() schema.Schema {
 	capellaschema.AddAttr(attrs, "organization_id", privateEndpointsBuilder, requiredString())
 	capellaschema.AddAttr(attrs, "project_id", privateEndpointsBuilder, requiredString())
 	capellaschema.AddAttr(attrs, "cluster_id", privateEndpointsBuilder, requiredString())
-	capellaschema.AddAttr(attrs, "private_endpoint_dns", privateEndpointsBuilder, computedString())
 
 	dataAttrs := make(map[string]schema.Attribute)
 	capellaschema.AddAttr(dataAttrs, "id", privateEndpointsBuilder, computedString())
 	capellaschema.AddAttr(dataAttrs, "organization_id", privateEndpointsBuilder, computedString())
 	capellaschema.AddAttr(dataAttrs, "project_id", privateEndpointsBuilder, computedString())
 	capellaschema.AddAttr(dataAttrs, "cluster_id", privateEndpointsBuilder, computedString())
+	capellaschema.AddAttr(dataAttrs, "cloud_provider", privateEndpointsBuilder, computedString())
 	capellaschema.AddAttr(dataAttrs, "status", privateEndpointsBuilder, computedString())
-	capellaschema.AddAttr(dataAttrs, "service_name", privateEndpointsBuilder, computedString())
 
 	capellaschema.AddAttr(attrs, "data", privateEndpointsBuilder, &schema.ListNestedAttribute{
 		Computed: true,

internal/errors/errors.go

@@ -273,7 +273,4 @@ var (
 		" the state from remote, unexpected error: ")
 
 	ErrCannotSetIopsForGcp = errors.New("iops cannot be set for GCP clusters.")
-
-	// ErrPrivateEndpointTimeout is returned when private endpoint does not reach linked status or DNS is not populated.
-	ErrPrivateEndpointTimeout = errors.New("private endpoint linking timed out: status not linked or DNS not populated")
 )

internal/resources/private_endpoints.go

@@ -5,12 +5,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"time"
 
 	"github.com/hashicorp/terraform-plugin-framework/path"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
 	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
 
 	"github.com/couchbasecloud/terraform-provider-couchbase-capella/internal/api"
 	"github.com/couchbasecloud/terraform-provider-couchbase-capella/internal/errors"
@@ -24,10 +22,6 @@ var (
 	_ resource.ResourceWithImportState = &PrivateEndpoint{}
 )
 
-const (
-	privateEndpointLinkedStatus = "linked"
-)
-
 // PrivateEndpoint is the private endpoint resource implementation.
 type PrivateEndpoint struct {
 	*providerschema.Data
@@ -98,28 +92,27 @@ func (p *PrivateEndpoint) Create(ctx context.Context, req resource.CreateRequest
 		return
 	}
 
-	plan.Status = types.StringNull()
-	plan.ServiceName = types.StringNull()
-	plan.PrivateEndpointDNS = types.StringNull()
-
-	diags = resp.State.Set(ctx, plan)
+	diags = resp.State.Set(ctx, initializePrivateEndpointPlan(plan))
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
 		return
 	}
 
-	err = p.waitUntilLinked(ctx, &plan)
+	refreshedState, err := p.getPrivateEndpointState(ctx, organizationId, projectId, clusterId, endpointId)
 	if err != nil {
 		resp.Diagnostics.AddError(
-			"Error waiting for private endpoint to be linked",
-			"Error waiting for private endpoint to be linked, unexpected error: "+err.Error(),
+			"Error reading private endpoint service status",
+			"Error reading private endpoint service status, unexpected error: "+err.Error(),
 		)
 
 		return
 	}
 
-	diags = resp.State.Set(ctx, plan)
+	diags = resp.State.Set(ctx, refreshedState)
 	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
 }
 
 // Read reads the private endpoint status.
@@ -264,29 +257,37 @@ func validateAcceptPrivateEndpoint(plan providerschema.PrivateEndpoint) error {
 	return nil
 }
 
+// initializePrivateEndpointPlan initializes an instance of providerschema.PrivateEndpoint
+// with the specified plan. It marks all computed fields as null.
+func initializePrivateEndpointPlan(plan providerschema.PrivateEndpoint) providerschema.PrivateEndpoint {
+	if plan.Status.IsNull() || plan.Status.IsUnknown() {
+		plan.Status = types.StringNull()
+	}
+	return plan
+}
+
 // getPrivateEndpointState morphs private endpoint status to terraform schema.
 func (p *PrivateEndpoint) getPrivateEndpointState(ctx context.Context, organizationId, projectId, clusterId, endpointId string) (*providerschema.PrivateEndpoint, error) {
-	status, serviceName, dns, err := p.getPrivateEndpointStatus(ctx, organizationId, projectId, clusterId, endpointId)
+	status, serviceName, err := p.getPrivateEndpointStatus(ctx, organizationId, projectId, clusterId, endpointId)
 	if err != nil {
 		return nil, err
 	}
 
 	state := providerschema.PrivateEndpoint{
-		EndpointId:         types.StringValue(endpointId),
-		Status:             types.StringValue(status),
-		ClusterId:          types.StringValue(clusterId),
-		ProjectId:          types.StringValue(projectId),
-		OrganizationId:     types.StringValue(organizationId),
-		ServiceName:        types.StringValue(serviceName),
-		PrivateEndpointDNS: types.StringValue(dns),
+		EndpointId:     types.StringValue(endpointId),
+		Status:         types.StringValue(status),
+		ClusterId:      types.StringValue(clusterId),
+		ProjectId:      types.StringValue(projectId),
+		OrganizationId: types.StringValue(organizationId),
+		ServiceName:    types.StringValue(serviceName),
 	}
 
 	return &state, nil
 }
 
 // There is currently no V4 endpoint to get a single private endpoint.  We have to loop through the entire list to find
 // the desired private endpoint.
-func (p *PrivateEndpoint) getPrivateEndpointStatus(ctx context.Context, organizationId, projectId, clusterId, endpointId string) (string, string, string, error) {
+func (p *PrivateEndpoint) getPrivateEndpointStatus(ctx context.Context, organizationId, projectId, clusterId, endpointId string) (string, string, error) {
 	url := fmt.Sprintf("%s/v4/organizations/%s/projects/%s/clusters/%s/privateEndpointService/endpoints", p.HostURL, organizationId, projectId, clusterId)
 	cfg := api.EndpointCfg{Url: url, Method: http.MethodGet, SuccessStatus: http.StatusOK}
 	response, err := p.ClientV1.ExecuteWithRetry(
@@ -297,63 +298,20 @@ func (p *PrivateEndpoint) getPrivateEndpointStatus(ctx context.Context, organiza
 		nil,
 	)
 	if err != nil {
-		return "", "", "", err
+		return "", "", err
 	}
 
 	privateEndpointsResp := api.GetPrivateEndpointsResponse{}
 	err = json.Unmarshal(response.Body, &privateEndpointsResp)
 	if err != nil {
-		return "", "", "", err
+		return "", "", err
 	}
 
 	for _, e := range privateEndpointsResp.Endpoints {
 		if e.Id == endpointId {
-			return e.Status, e.ServiceName, privateEndpointsResp.PrivateEndpointDNS, nil
+			return e.Status, e.ServiceName, nil
 		}
 	}
 
-	return "", "", "", errors.ErrNotFound
-}
-
-// waitUntilLinked polls the private endpoint until it reaches linked status and DNS is populated.
-func (p *PrivateEndpoint) waitUntilLinked(ctx context.Context, plan *providerschema.PrivateEndpoint) error {
-	var cancel context.CancelFunc
-	ctx, cancel = context.WithTimeout(ctx, time.Minute*5)
-	defer cancel()
-
-	timer := time.NewTimer(time.Second * 1)
-	defer timer.Stop()
-
-	for {
-		select {
-		case <-ctx.Done():
-			return errors.ErrPrivateEndpointTimeout
-
-		case <-timer.C:
-			status, serviceName, dns, err := p.getPrivateEndpointStatus(
-				ctx,
-				plan.OrganizationId.ValueString(),
-				plan.ProjectId.ValueString(),
-				plan.ClusterId.ValueString(),
-				plan.EndpointId.ValueString(),
-			)
-			if err != nil {
-				return err
-			}
-
-			if status == privateEndpointLinkedStatus {
-				if dns == "" {
-					tflog.Info(ctx, "Private endpoint is linked but DNS is not populated.")
-					timer.Reset(time.Minute * 1)
-					continue
-				}
-				plan.ServiceName = types.StringValue(serviceName)
-				plan.Status = types.StringValue(status)
-				plan.PrivateEndpointDNS = types.StringValue(dns)
-				return nil
-			}
-			tflog.Info(ctx, "Private endpoint is not linked.")
-			timer.Reset(time.Minute * 1)
-		}
-	}
+	return "", "", errors.ErrNotFound
 }

internal/resources/private_endpoints_schema.go

@@ -17,7 +17,6 @@ func PrivateEndpointsSchema() schema.Schema {
 	capellaschema.AddAttr(attrs, "endpoint_id", privateEndpointsBuilder, stringAttribute([]string{required, requiresReplace}))
 	capellaschema.AddAttr(attrs, "status", privateEndpointsBuilder, stringAttribute([]string{computed}))
 	capellaschema.AddAttr(attrs, "service_name", privateEndpointsBuilder, stringAttribute([]string{computed}))
-	capellaschema.AddAttr(attrs, "private_endpoint_dns", privateEndpointsBuilder, stringAttribute([]string{computed}))
 
 	return schema.Schema{
 		MarkdownDescription: "This resource allows you to manage private endpoints for an operational cluster. Private endpoints allow you to securely connect your Cloud Service Provider's private network (VPC/VNET) to your operational cluster without exposing traffic to the public internet.",

internal/schema/private_endpoints.go

@@ -28,28 +28,24 @@ type PrivateEndpoint struct {
 
 	// ServiceName is the name of the private endpoint service.
 	ServiceName types.String `tfsdk:"service_name"`
-
-	// PrivateEndpointDNS is the DNS of the private endpoint.
-	PrivateEndpointDNS types.String `tfsdk:"private_endpoint_dns"`
 }
 
 // PrivateEndpoints defines a structure used by the LIST endpoint for private endpoints.
 type PrivateEndpoints struct {
-	ClusterId          types.String          `tfsdk:"cluster_id"`
-	ProjectId          types.String          `tfsdk:"project_id"`
-	OrganizationId     types.String          `tfsdk:"organization_id"`
-	PrivateEndpointDNS types.String          `tfsdk:"private_endpoint_dns"`
-	Data               []PrivateEndpointData `tfsdk:"data"`
+	ClusterId      types.String          `tfsdk:"cluster_id"`
+	ProjectId      types.String          `tfsdk:"project_id"`
+	OrganizationId types.String          `tfsdk:"organization_id"`
+	Data           []PrivateEndpointData `tfsdk:"data"`
 }
 
 // PrivateEndpointData defines a single private endpoint.
 type PrivateEndpointData struct {
-	Id             types.String `tfsdk:"id"`
-	OrganizationId types.String `tfsdk:"organization_id"`
-	ProjectId      types.String `tfsdk:"project_id"`
-	ClusterId      types.String `tfsdk:"cluster_id"`
-	Status         types.String `tfsdk:"status"`
-	ServiceName    types.String `tfsdk:"service_name"`
+	// Id is the endpoint id.
+	Id types.String `tfsdk:"id"`
+	// Status is the endpoint status.  Possible values are failed, linked, pending, pendingAcceptance, rejected and unrecognized.
+	Status types.String `tfsdk:"status"`
+	// ServiceName is the name of the endpoint service.
+	ServiceName types.String `tfsdk:"service_name"`
 }
 
 // Validate is used to verify that IDs have been properly imported.