feat: support non blocking mode in TeardownAndDestroy state method

This mode is useful in the controllers. It can call this method
repeatedly.

Signed-off-by: Artem Chernyshev <artem.chernyshev@talos-systems.com>

Author: Unix4ever

pkg/state/conformance/state.go

@@ -1406,12 +1406,14 @@ func (suite *StateSuite) TestContextWithTeardown() {
 func (suite *StateSuite) TestTeardownAndDestroy() {
 	ns := suite.getNamespace()
 
-	res := NewPathResource(ns, "tmp/4")
+	path1 := NewPathResource(ns, "tmp/4")
+	path2 := NewPathResource(ns, "tmp/5")
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
 
-	finalizer := "A"
+	finalizerA := "A"
+	finalizerB := "B"
 
 	eg := errgroup.Group{}
 
@@ -1436,23 +1438,42 @@ func (suite *StateSuite) TestTeardownAndDestroy() {
 					continue
 				}
 
-				if !e.Resource.Metadata().Finalizers().Has(finalizer) {
+				if !e.Resource.Metadata().Finalizers().Has(finalizerA) {
 					continue
 				}
 
-				if err = suite.State.RemoveFinalizer(ctx, e.Resource.Metadata(), finalizer); err != nil {
+				if err = suite.State.RemoveFinalizer(ctx, e.Resource.Metadata(), finalizerA); err != nil {
 					return err
 				}
 			}
 		}
 	})
 
-	suite.Require().NoError(suite.State.Create(ctx, res))
+	suite.Require().NoError(suite.State.Create(ctx, path1))
+	suite.Require().NoError(suite.State.Create(ctx, path2))
+
+	suite.Assert().NoError(suite.State.AddFinalizer(ctx, path1.Metadata(), finalizerA))
+	suite.Assert().NoError(suite.State.AddFinalizer(ctx, path2.Metadata(), finalizerB))
 
-	suite.Assert().NoError(suite.State.AddFinalizer(ctx, res.Metadata(), finalizer))
+	_, err := suite.State.TeardownAndDestroy(ctx, path1.Metadata())
+	suite.Require().NoError(err)
+
+	ready, err := suite.State.TeardownAndDestroy(ctx, path2.Metadata(), state.WithNoBlocking())
+	suite.Require().NoError(err)
+	suite.Assert().False(ready)
 
-	err := suite.State.TeardownAndDestroy(ctx, res.Metadata())
+	r, err := suite.State.Get(ctx, path2.Metadata())
 	suite.Require().NoError(err)
+	suite.Assert().Equal(resource.PhaseTearingDown, r.Metadata().Phase())
+
+	suite.Assert().NoError(suite.State.RemoveFinalizer(ctx, path2.Metadata(), finalizerB))
+
+	ready, err = suite.State.TeardownAndDestroy(ctx, path2.Metadata(), state.WithNoBlocking())
+	suite.Assert().True(ready)
+	suite.Require().NoError(err)
+
+	_, err = suite.State.Get(ctx, path2.Metadata())
+	suite.Require().True(state.IsNotFoundError(err))
 
 	cancel()
 

pkg/state/options.go

@@ -157,7 +157,8 @@ type TeardownAndDestroyOption func(*TeardownAndDestroyOptions)
 
 // TeardownAndDestroyOptions for the CoreState.TeardownAndDestroy function.
 type TeardownAndDestroyOptions struct {
-	Owner string
+	Owner       string
+	NonBlocking bool
 }
 
 // WithTeardownAndDestroyOwner checks an owner on the object being destroyed.
@@ -167,6 +168,14 @@ func WithTeardownAndDestroyOwner(owner string) TeardownAndDestroyOption {
 	}
 }
 
+// WithNoBlocking makes teardown and destroy not wait for finalizers empty.
+// Then if the finalizers empty it will try destroying the resource.
+func WithNoBlocking() TeardownAndDestroyOption {
+	return func(opts *TeardownAndDestroyOptions) {
+		opts.NonBlocking = true
+	}
+}
+
 // WatchOptions for the CoreState.Watch function.
 type WatchOptions struct {
 	StartFromBookmark Bookmark

pkg/state/state.go

@@ -143,5 +143,5 @@ type State interface {
 	// If a resource doesn't exist, error is returned.
 	// It's not an error to tear down a resource which is already being torn down.
 	// The call blocks until all resource finalizers are empty.
-	TeardownAndDestroy(context.Context, resource.Pointer, ...TeardownAndDestroyOption) error
+	TeardownAndDestroy(context.Context, resource.Pointer, ...TeardownAndDestroyOption) (bool, error)
 }

pkg/state/wrap.go

@@ -214,7 +214,7 @@ func (state coreWrapper) ContextWithTeardown(ctx context.Context, resourcePointe
 // If a resource doesn't exist, error is returned.
 // It's not an error to tear down a resource which is already being torn down.
 // The call blocks until all resource finalizers are empty.
-func (state coreWrapper) TeardownAndDestroy(ctx context.Context, resourcePointer resource.Pointer, opts ...TeardownAndDestroyOption) error {
+func (state coreWrapper) TeardownAndDestroy(ctx context.Context, resourcePointer resource.Pointer, opts ...TeardownAndDestroyOption) (bool, error) {
 	var options TeardownAndDestroyOptions
 
 	for _, opt := range opts {
@@ -223,17 +223,21 @@ func (state coreWrapper) TeardownAndDestroy(ctx context.Context, resourcePointer
 
 	ready, err := state.Teardown(ctx, resourcePointer, WithTeardownOwner(options.Owner))
 	if err != nil {
-		return err
+		return ready, err
 	}
 
 	if ready {
-		return state.Destroy(ctx, resourcePointer, WithDestroyOwner(options.Owner))
+		return ready, state.Destroy(ctx, resourcePointer, WithDestroyOwner(options.Owner))
+	}
+
+	if options.NonBlocking {
+		return ready, nil
 	}
 
 	_, err = state.WatchFor(ctx, resourcePointer, WithFinalizerEmpty())
 	if err != nil {
-		return err
+		return ready, err
 	}
 
-	return state.Destroy(ctx, resourcePointer, WithDestroyOwner(options.Owner))
+	return true, state.Destroy(ctx, resourcePointer, WithDestroyOwner(options.Owner))
 }