feat: implement TeardownAndDestroy helper function

The function combines `Teardown`, `Watch` for finalizers to be empty and
`Destroy` calls.

Fixes: siderolabs/omni#1137

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

Author: Unix4ever

pkg/state/conformance/state.go

@@ -1402,6 +1402,63 @@ func (suite *StateSuite) TestContextWithTeardown() {
 	assertContextIsCanceled(suite.T(), ctx2)
 }
 
+// TestTeardownAndDestroy verifies TeardownAndDestroy.
+func (suite *StateSuite) TestTeardownAndDestroy() {
+	ns := suite.getNamespace()
+
+	res := NewPathResource(ns, "tmp/4")
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+
+	finalizer := "A"
+
+	eg := errgroup.Group{}
+
+	eg.Go(func() error {
+		ch := make(chan state.Event)
+
+		err := suite.State.WatchKind(ctx, NewPathResource(ns, "").Metadata(), ch, state.WithBootstrapContents(true))
+		if err != nil {
+			return err
+		}
+
+		for {
+			select {
+			case <-ctx.Done():
+				return nil
+			case e := <-ch:
+				if e.Type != state.Updated && e.Type != state.Created {
+					continue
+				}
+
+				if e.Resource.Metadata().Phase() != resource.PhaseTearingDown {
+					continue
+				}
+
+				if !e.Resource.Metadata().Finalizers().Has(finalizer) {
+					continue
+				}
+
+				if err = suite.State.RemoveFinalizer(ctx, e.Resource.Metadata(), finalizer); err != nil {
+					return err
+				}
+			}
+		}
+	})
+
+	suite.Require().NoError(suite.State.Create(ctx, res))
+
+	suite.Assert().NoError(suite.State.AddFinalizer(ctx, res.Metadata(), finalizer))
+
+	err := suite.State.TeardownAndDestroy(ctx, res.Metadata())
+	suite.Require().NoError(err)
+
+	cancel()
+
+	suite.Require().NoError(eg.Wait())
+}
+
 func assertContextIsCanceled(t *testing.T, ctx context.Context) { //nolint:revive
 	t.Helper()
 

pkg/state/options.go

@@ -152,6 +152,21 @@ func WithDestroyOwner(owner string) DestroyOption {
 	}
 }
 
+// TeardownAndDestroyOption builds TeardownAndDestroyOption.
+type TeardownAndDestroyOption func(*TeardownAndDestroyOptions)
+
+// TeardownAndDestroyOptions for the CoreState.TeardownAndDestroy function.
+type TeardownAndDestroyOptions struct {
+	Owner string
+}
+
+// WithTeardownAndDestroyOwner checks an owner on the object being destroyed.
+func WithTeardownAndDestroyOwner(owner string) TeardownAndDestroyOption {
+	return func(opts *TeardownAndDestroyOptions) {
+		opts.Owner = owner
+	}
+}
+
 // WatchOptions for the CoreState.Watch function.
 type WatchOptions struct {
 	StartFromBookmark Bookmark

pkg/state/state.go

@@ -137,4 +137,11 @@ type State interface {
 	// The passed in context should be canceled, otherwise the goroutine might leak from this call.
 	// If the resource doesn't exist, the context is canceled immediately.
 	ContextWithTeardown(context.Context, resource.Pointer) (context.Context, error)
+
+	// TeardownAndDestroy a resource.
+	//
+	// 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
 }

pkg/state/wrap.go

@@ -208,3 +208,32 @@ func (state coreWrapper) ContextWithTeardown(ctx context.Context, resourcePointe
 
 	return ctx, nil
 }
+
+// TeardownAndDestroy a resource.
+//
+// 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 {
+	var options TeardownAndDestroyOptions
+
+	for _, opt := range opts {
+		opt(&options)
+	}
+
+	ready, err := state.Teardown(ctx, resourcePointer, WithTeardownOwner(options.Owner))
+	if err != nil {
+		return err
+	}
+
+	if ready {
+		return state.Destroy(ctx, resourcePointer, WithDestroyOwner(options.Owner))
+	}
+
+	_, err = state.WatchFor(ctx, resourcePointer, WithFinalizerEmpty())
+	if err != nil {
+		return err
+	}
+
+	return state.Destroy(ctx, resourcePointer, WithDestroyOwner(options.Owner))
+}