Implement Disconnect on ExternalClient interface

Signed-off-by: smcavallo <[email protected]>

pkg/controller/external.go

@@ -140,6 +140,10 @@ type external struct {
 	logger            logging.Logger
 }
 
+func (e *external) Disconnect(ctx context.Context) error {
+	return nil
+}
+
 func (e *external) scheduleProvider(name string) (bool, error) {
 	if e.providerScheduler == nil || e.workspace == nil {
 		return false, nil

pkg/controller/external_async_tfpluginfw.go

@@ -224,13 +224,13 @@ func (n *terraformPluginFrameworkAsyncExternalClient) Update(_ context.Context,
 	return managed.ExternalUpdate{}, n.opTracker.LastOperation.Error()
 }
 
-func (n *terraformPluginFrameworkAsyncExternalClient) Delete(_ context.Context, mg xpresource.Managed) error { //nolint:contextcheck // we intentionally use a fresh context for the async operation
+func (n *terraformPluginFrameworkAsyncExternalClient) Delete(_ context.Context, mg xpresource.Managed) (managed.ExternalDelete, error) { //nolint:contextcheck // we intentionally use a fresh context for the async operation
 	switch {
 	case n.opTracker.LastOperation.Type == "delete":
 		n.opTracker.logger.Debug("The previous delete operation is still ongoing")
-		return nil
+		return managed.ExternalDelete{}, nil
 	case !n.opTracker.LastOperation.MarkStart("delete"):
-		return errors.Errorf("%s operation that started at %s is still running", n.opTracker.LastOperation.Type, n.opTracker.LastOperation.StartTime().String())
+		return managed.ExternalDelete{}, errors.Errorf("%s operation that started at %s is still running", n.opTracker.LastOperation.Type, n.opTracker.LastOperation.StartTime().String())
 	}
 
 	ctx, cancel := context.WithDeadline(context.Background(), n.opTracker.LastOperation.StartTime().Add(defaultAsyncTimeout))
@@ -255,8 +255,12 @@ func (n *terraformPluginFrameworkAsyncExternalClient) Delete(_ context.Context,
 		defer ph.recoverIfPanic()
 
 		n.opTracker.logger.Debug("Async delete starting...")
-		ph.err = n.terraformPluginFrameworkExternalClient.Delete(ctx, mg)
+		_, ph.err = n.terraformPluginFrameworkExternalClient.Delete(ctx, mg)
 	}()
 
-	return n.opTracker.LastOperation.Error()
+	return managed.ExternalDelete{}, n.opTracker.LastOperation.Error()
+}
+
+func (n *terraformPluginFrameworkAsyncExternalClient) Disconnect(_ context.Context) error {
+	return nil
 }

pkg/controller/external_async_tfpluginsdk.go

@@ -202,13 +202,13 @@ func (n *terraformPluginSDKAsyncExternal) Update(_ context.Context, mg xpresourc
 	return managed.ExternalUpdate{}, n.opTracker.LastOperation.Error()
 }
 
-func (n *terraformPluginSDKAsyncExternal) Delete(_ context.Context, mg xpresource.Managed) error { //nolint:contextcheck // we intentionally use a fresh context for the async operation
+func (n *terraformPluginSDKAsyncExternal) Delete(_ context.Context, mg xpresource.Managed) (managed.ExternalDelete, error) { //nolint:contextcheck // we intentionally use a fresh context for the async operation
 	switch {
 	case n.opTracker.LastOperation.Type == "delete":
 		n.opTracker.logger.Debug("The previous delete operation is still ongoing", "tfID", n.opTracker.GetTfID())
-		return nil
+		return managed.ExternalDelete{}, nil
 	case !n.opTracker.LastOperation.MarkStart("delete"):
-		return errors.Errorf("%s operation that started at %s is still running", n.opTracker.LastOperation.Type, n.opTracker.LastOperation.StartTime().String())
+		return managed.ExternalDelete{}, errors.Errorf("%s operation that started at %s is still running", n.opTracker.LastOperation.Type, n.opTracker.LastOperation.StartTime().String())
 	}
 
 	ctx, cancel := context.WithDeadline(context.Background(), n.opTracker.LastOperation.StartTime().Add(defaultAsyncTimeout))
@@ -233,8 +233,12 @@ func (n *terraformPluginSDKAsyncExternal) Delete(_ context.Context, mg xpresourc
 		defer ph.recoverIfPanic()
 
 		n.opTracker.logger.Debug("Async delete starting...", "tfID", n.opTracker.GetTfID())
-		ph.err = n.terraformPluginSDKExternal.Delete(ctx, mg)
+		_, ph.err = n.terraformPluginSDKExternal.Delete(ctx, mg)
 	}()
 
-	return n.opTracker.LastOperation.Error()
+	return managed.ExternalDelete{}, n.opTracker.LastOperation.Error()
+}
+
+func (n *terraformPluginSDKAsyncExternal) Disconnect(_ context.Context) error {
+	return nil
 }

pkg/controller/external_async_tfpluginsdk_test.go

@@ -327,7 +327,7 @@ func TestAsyncTerraformPluginSDKDelete(t *testing.T) {
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
 			terraformPluginSDKAsyncExternal := prepareTerraformPluginSDKAsyncExternal(tc.args.r, tc.args.cfg, tc.args.fns)
-			err := terraformPluginSDKAsyncExternal.Delete(context.TODO(), tc.args.obj)
+			_, err := terraformPluginSDKAsyncExternal.Delete(context.TODO(), tc.args.obj)
 			if diff := cmp.Diff(tc.want.err, err, test.EquateErrors()); diff != "" {
 				t.Errorf("\n%s\nConnect(...): -want error, +got error:\n", diff)
 			}

pkg/controller/external_test.go

@@ -816,7 +816,7 @@ func TestDelete(t *testing.T) {
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
 			e := &external{workspace: tc.w, callback: tc.c, config: tc.cfg}
-			err := e.Delete(context.TODO(), tc.args.obj)
+			_, err := e.Delete(context.TODO(), tc.args.obj)
 			if diff := cmp.Diff(tc.want.err, err, test.EquateErrors()); diff != "" {
 				t.Errorf("\n%s\nCreate(...): -want error, +got error:\n%s", tc.reason, diff)
 			}

pkg/controller/external_tfpluginfw.go

@@ -520,17 +520,17 @@ func (n *terraformPluginFrameworkExternalClient) Update(ctx context.Context, mg
 	return managed.ExternalUpdate{}, nil
 }
 
-func (n *terraformPluginFrameworkExternalClient) Delete(ctx context.Context, _ xpresource.Managed) error {
+func (n *terraformPluginFrameworkExternalClient) Delete(ctx context.Context, _ xpresource.Managed) (managed.ExternalDelete, error) {
 	n.logger.Debug("Deleting the external resource")
 
 	tfConfigDynamicVal, err := protov5DynamicValueFromMap(n.params, n.resourceValueTerraformType)
 	if err != nil {
-		return errors.Wrap(err, "cannot construct dynamic value for TF Config")
+		return managed.ExternalDelete{}, errors.Wrap(err, "cannot construct dynamic value for TF Config")
 	}
 	// set an empty planned state, this corresponds to deleting
 	plannedState, err := tfprotov5.NewDynamicValue(n.resourceValueTerraformType, tftypes.NewValue(n.resourceValueTerraformType, nil))
 	if err != nil {
-		return errors.Wrap(err, "cannot set the planned state for deletion")
+		return managed.ExternalDelete{}, errors.Wrap(err, "cannot set the planned state for deletion")
 	}
 
 	applyRequest := &tfprotov5.ApplyResourceChangeRequest{
@@ -542,22 +542,22 @@ func (n *terraformPluginFrameworkExternalClient) Delete(ctx context.Context, _ x
 	start := time.Now()
 	applyResponse, err := n.server.ApplyResourceChange(ctx, applyRequest)
 	if err != nil {
-		return errors.Wrap(err, "cannot delete resource")
+		return managed.ExternalDelete{}, errors.Wrap(err, "cannot delete resource")
 	}
 	metrics.ExternalAPITime.WithLabelValues("delete").Observe(time.Since(start).Seconds())
 	if fatalDiags := getFatalDiagnostics(applyResponse.Diagnostics); fatalDiags != nil {
-		return errors.Wrap(fatalDiags, "resource deletion call returned error diags")
+		return managed.ExternalDelete{}, errors.Wrap(fatalDiags, "resource deletion call returned error diags")
 	}
 	n.opTracker.SetFrameworkTFState(applyResponse.NewState)
 
 	newStateAfterApplyVal, err := applyResponse.NewState.Unmarshal(n.resourceValueTerraformType)
 	if err != nil {
-		return errors.Wrap(err, "cannot unmarshal state after deletion")
+		return managed.ExternalDelete{}, errors.Wrap(err, "cannot unmarshal state after deletion")
 	}
 	// mark the resource as logically deleted if the TF call clears the state
 	n.opTracker.SetDeleted(newStateAfterApplyVal.IsNull())
 
-	return nil
+	return managed.ExternalDelete{}, nil
 }
 
 func (n *terraformPluginFrameworkExternalClient) setExternalName(mg xpresource.Managed, stateValueMap map[string]interface{}) (bool, error) {
@@ -713,3 +713,7 @@ func protov5DynamicValueFromMap(data map[string]any, terraformType tftypes.Type)
 
 	return &dynamicValue, nil
 }
+
+func (n *terraformPluginFrameworkExternalClient) Disconnect(_ context.Context) error {
+	return nil
+}

pkg/controller/external_tfpluginfw_test.go

@@ -502,7 +502,7 @@ func TestTPFDelete(t *testing.T) {
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
 			tpfExternal := prepareTPFExternalWithTestConfig(tc.testConfiguration)
-			err := tpfExternal.Delete(context.TODO(), &tc.testConfiguration.obj)
+			_, err := tpfExternal.Delete(context.TODO(), &tc.testConfiguration.obj)
 			if diff := cmp.Diff(tc.want.err, err, test.EquateErrors()); diff != "" {
 				t.Errorf("\n%s\nConnect(...): -want error, +got error:\n", diff)
 			}

pkg/controller/external_tfpluginsdk.go

@@ -703,7 +703,7 @@ func (n *terraformPluginSDKExternal) Update(ctx context.Context, mg xpresource.M
 	return managed.ExternalUpdate{}, nil
 }
 
-func (n *terraformPluginSDKExternal) Delete(ctx context.Context, _ xpresource.Managed) error {
+func (n *terraformPluginSDKExternal) Delete(ctx context.Context, _ xpresource.Managed) (managed.ExternalDelete, error) {
 	n.logger.Debug("Deleting the external resource")
 	if n.instanceDiff == nil {
 		n.instanceDiff = tf.NewInstanceDiff()
@@ -714,11 +714,15 @@ func (n *terraformPluginSDKExternal) Delete(ctx context.Context, _ xpresource.Ma
 	newState, diag := n.resourceSchema.Apply(ctx, n.opTracker.GetTfState(), n.instanceDiff, n.ts.Meta)
 	metrics.ExternalAPITime.WithLabelValues("delete").Observe(time.Since(start).Seconds())
 	if diag != nil && diag.HasError() {
-		return errors.Errorf("failed to delete the resource: %v", diag)
+		return managed.ExternalDelete{}, errors.Errorf("failed to delete the resource: %v", diag)
 	}
 	n.opTracker.SetTfState(newState)
 	// mark the resource as logically deleted if the TF call clears the state
 	n.opTracker.SetDeleted(newState == nil)
+	return managed.ExternalDelete{}, nil
+}
+
+func (n *terraformPluginSDKExternal) Disconnect(_ context.Context) error {
 	return nil
 }
 

pkg/controller/external_tfpluginsdk_test.go

@@ -396,7 +396,7 @@ func TestTerraformPluginSDKDelete(t *testing.T) {
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
 			terraformPluginSDKExternal := prepareTerraformPluginSDKExternal(tc.args.r, tc.args.cfg)
-			err := terraformPluginSDKExternal.Delete(context.TODO(), &tc.args.obj)
+			_, err := terraformPluginSDKExternal.Delete(context.TODO(), &tc.args.obj)
 			if diff := cmp.Diff(tc.want.err, err, test.EquateErrors()); diff != "" {
 				t.Errorf("\n%s\nConnect(...): -want error, +got error:\n", diff)
 			}