feat: add context to support cancel to tool ops (#1380)

<!-- markdownlint-disable MD041 -->
#### What this PR does / why we need it

This PR changes the internal tool operations for signing and transfer to
use a `context.Context`.
This context can be used to cancel the operations. The check is always
done before a new component version is
handled. This means, if cancelled, the actual component version handled
after a cancel will always be finished before
the operation is cancelled.

The consumer facing operations are added to provide versions accepting a
context.

#### Which issue(s) this PR fixes
Fixes #1346

---------

Co-authored-by: Jakob Möller <[email protected]>

Author: mandelsoft

api/config/configutils/configure.go

@@ -9,11 +9,17 @@ import (
 	utils "ocm.software/ocm/api/ocm/ocmutils"
 )
 
+// Configure configures the default context applying
+// a configuration file.
+// It also applies implicit settings from the OCM context.
 func Configure(path string, fss ...vfs.FileSystem) error {
 	_, err := utils.Configure(config.DefaultContext(), path, fss...)
 	return err
 }
 
+// ConfigureContext configures the given context applying
+// a configuration file.
+// It also applies implicit settings from the OCM context.
 func ConfigureContext(ctxp config.ContextProvider, path string, fss ...vfs.FileSystem) error {
 	_, err := utils.Configure(ctxp, path, fss...)
 	return err

api/ocm/tools/signing/handle.go

@@ -1,6 +1,7 @@
 package signing
 
 import (
+	"context"
 	"crypto"
 	"encoding/hex"
 	"fmt"
@@ -107,14 +108,22 @@ func Apply(printer common.Printer, state *WalkingState, cv ocm.ComponentVersionA
 		opts = opts.Dup()
 		opts.Printer = printer
 	}
+	return ApplyWithContext(context.Background(), state, cv, opts, closecv...)
+}
+
+func ApplyWithContext(ctx context.Context, state *WalkingState, cv ocm.ComponentVersionAccess, opts *Options, closecv ...bool) (*metav1.DigestSpec, error) {
+	if opts.Printer == nil {
+		opts = opts.Dup()
+		opts.Printer = common.GetPrinter(ctx)
+	}
 	err := opts.Complete(cv.GetContext())
 	if err != nil {
 		return nil, err
 	}
 	if state == nil {
 		state = DefaultWalkingState(cv.GetContext())
 	}
-	dc, err := apply(*state, cv, opts, general.Optional(closecv...))
+	dc, err := apply(ctx, *state, cv, opts, general.Optional(closecv...))
 	if err != nil {
 		return nil, err
 	}
@@ -140,7 +149,7 @@ func RequireReProcessing(vi *VersionInfo, ctx *DigestContext, opts *Options) boo
 	return opts.DoSign() && !vi.digestingContexts[ctx.CtxKey].Signed
 }
 
-func apply(state WalkingState, cv ocm.ComponentVersionAccess, opts *Options, closecv bool) (dc *DigestContext, efferr error) {
+func apply(ctx context.Context, state WalkingState, cv ocm.ComponentVersionAccess, opts *Options, closecv bool) (dc *DigestContext, efferr error) {
 	var closer errors.ErrorFunction
 	if closecv {
 		closer = func() error {
@@ -163,10 +172,15 @@ func apply(state WalkingState, cv ocm.ComponentVersionAccess, opts *Options, clo
 			return dc, nil
 		}
 	}
-	return _apply(state, nv, cv, vi, opts)
+	return _apply(ctx, state, nv, cv, vi, opts)
 }
 
-func _apply(state WalkingState, nv common.NameVersion, cv ocm.ComponentVersionAccess, vi *VersionInfo, opts *Options) (*DigestContext, error) { //nolint: maintidx // yes
+func _apply(cctx context.Context, state WalkingState, nv common.NameVersion, cv ocm.ComponentVersionAccess, vi *VersionInfo, opts *Options) (*DigestContext, error) { //nolint: maintidx // yes
+	if err := common.IsContextCanceled(cctx); err != nil {
+		opts.Printer.Printf("cancelled by caller\n")
+		return nil, err
+	}
+
 	prefix := ""
 	var ctx *DigestContext
 	if vi == nil {
@@ -213,7 +227,7 @@ func _apply(state WalkingState, nv common.NameVersion, cv ocm.ComponentVersionAc
 		// digests used for the existing signatures.
 		substate := state
 		substate.Context = nil
-		nctx, err := _apply(substate, nv, cv, vi, opts)
+		nctx, err := _apply(cctx, substate, nv, cv, vi, opts)
 		if err != nil {
 			return nil, err
 		}
@@ -253,10 +267,10 @@ func _apply(state WalkingState, nv common.NameVersion, cv ocm.ComponentVersionAc
 	var spec *metav1.DigestSpec
 	legacy := signing.IsLegacyHashAlgorithm(ctx.RootContextInfo.DigestType.HashAlgorithm) && !opts.DoSign()
 	if ctx.Digest == nil {
-		if err := calculateReferenceDigests(state, opts, legacy); err != nil {
+		if err := calculateReferenceDigests(cctx, state, opts, legacy); err != nil {
 			return nil, err
 		}
-		if err := calculateResourceDigests(state, cv, cd, opts, legacy, ctx.GetPreset(ctx.Key)); err != nil {
+		if err := calculateResourceDigests(cctx, state, cv, cd, opts, legacy, ctx.GetPreset(ctx.Key)); err != nil {
 			return nil, err
 		}
 		dt := ctx.DigestType
@@ -544,7 +558,7 @@ func GetPublicKeyFromSignature(sig *compdesc.Signature, sctx signing.SigningCont
 	return cert.PublicKey, nil
 }
 
-func calculateReferenceDigests(state WalkingState, opts *Options, legacy bool) (rerr error) {
+func calculateReferenceDigests(cctx context.Context, state WalkingState, opts *Options, legacy bool) (rerr error) {
 	var finalize finalizer.Finalizer
 	defer finalize.FinalizeWithErrorPropagation(&rerr)
 
@@ -568,7 +582,7 @@ func calculateReferenceDigests(state WalkingState, opts *Options, legacy bool) (
 
 		if nctx == nil || opts.Recursively || opts.Verify {
 			digestOpts := opts.Nested()
-			nctx, err = apply(state, nested, digestOpts, false)
+			nctx, err = apply(cctx, state, nested, digestOpts, false)
 			if err != nil {
 				return errors.Wrap(err, refMsg(reference, "failed applying to component reference"))
 			}
@@ -611,13 +625,18 @@ func calculateReferenceDigests(state WalkingState, opts *Options, legacy bool) (
 	return nil
 }
 
-func calculateResourceDigests(state WalkingState, cv ocm.ComponentVersionAccess, cd *compdesc.ComponentDescriptor, opts *Options, legacy bool, preset *metav1.NestedComponentDigests) (rerr error) {
+func calculateResourceDigests(cctx context.Context, state WalkingState, cv ocm.ComponentVersionAccess, cd *compdesc.ComponentDescriptor, opts *Options, legacy bool, preset *metav1.NestedComponentDigests) (rerr error) {
 	var finalize finalizer.Finalizer
 	defer finalize.FinalizeWithErrorPropagation(&rerr)
 
 	octx := cv.GetContext()
 	blobdigesters := octx.BlobDigesters()
 	for i, res := range cv.GetResources() {
+		if err := common.IsContextCanceled(cctx); err != nil {
+			opts.Printer.Printf("cancelled by caller\n")
+			return err
+		}
+
 		loop := finalize.Nested()
 
 		meta := res.Meta()

api/ocm/tools/signing/handler_test.go

@@ -1,9 +1,13 @@
 package signing_test
 
 import (
+	"context"
+
 	. "github.com/mandelsoft/goutils/testutils"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
+	"ocm.software/ocm/api/ocm/extensions/attrs/signingattr"
+	common "ocm.software/ocm/api/utils/misc"
 
 	"ocm.software/ocm/api/ocm"
 	v1 "ocm.software/ocm/api/ocm/compdesc/meta/v1"
@@ -34,6 +38,31 @@ var _ = Describe("Simple signing handlers", func() {
 			MustBeSuccessful(cv.SetResourceBlob(ocm.NewResourceMeta("blob", resourcetypes.PLAIN_TEXT, v1.LocalRelation), blobaccess.ForString(mime.MIME_TEXT, "test data"), "", nil))
 		})
 
+		It("cancelled", func() {
+			var opts signing.Options
+			p, buf := common.NewBufferedPrinter()
+			opts.Printer = p
+
+			opts.Eval(
+				signing.SignatureName("signature"),
+				signing.Update(),
+				signing.Recursive(),
+				signing.VerifyDigests(),
+
+				signing.PrivateKey("signature", priv),
+				signing.SignerByAlgo(rsa.Algorithm),
+			)
+
+			if opts.Signer == nil {
+				opts.Signer = signingattr.Get(cv.GetContext()).GetSigner(rsa.Algorithm)
+			}
+			MustBeSuccessful(opts.Complete(cv.GetContext()))
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+			ExpectError(signing.ApplyWithContext(ctx, nil, cv, &opts)).To(MatchError(context.Canceled))
+			Expect(buf.String()).To(Equal("cancelled by caller\n"))
+		})
+
 		DescribeTable("rsa handlers", func(kind string) {
 			Must(signing.SignComponentVersion(cv, "signature", signing.PrivateKey("signature", priv), signing.SignerByAlgo(kind)))
 			Must(signing.VerifyComponentVersion(cv, "signature", signing.PublicKey("signature", pub)))

api/ocm/tools/transfer/convenience.go

@@ -1,6 +1,8 @@
 package transfer
 
 import (
+	"context"
+
 	"ocm.software/ocm/api/ocm"
 	common "ocm.software/ocm/api/utils/misc"
 )
@@ -25,5 +27,23 @@ func Transfer(cv ocm.ComponentVersionAccess, tgt ocm.Repository, optlist ...Tran
 	if err != nil {
 		return err
 	}
-	return TransferWithHandler(local.printer, cv, tgt, h)
+	return TransferVersionWithContext(common.WithPrinter(context.Background(), local.printer), nil, cv, tgt, h)
+}
+
+// TransferWithContext uses the transfer handler based on the given options to control
+// the transfer process. The default handler is the standard handler.
+func TransferWithContext(ctx context.Context, cv ocm.ComponentVersionAccess, tgt ocm.Repository, optlist ...TransferOption) error {
+	h, err := NewTransferHandler(optlist...)
+	if err != nil {
+		return err
+	}
+	var local localOptions
+	err = local.Eval(optlist...)
+	if err != nil {
+		return err
+	}
+	if local.printer != nil {
+		ctx = common.WithPrinter(ctx, local.printer)
+	}
+	return TransferVersionWithContext(ctx, nil, cv, tgt, h)
 }

api/ocm/tools/transfer/transfer.go

@@ -1,6 +1,7 @@
 package transfer
 
 import (
+	"context"
 	"fmt"
 
 	"github.com/mandelsoft/goutils/errors"
@@ -23,14 +24,23 @@ type WalkingState = common.WalkingState[*struct{}, interface{}]
 type TransportClosure = common.NameVersionInfo[*struct{}]
 
 func TransferVersion(printer common.Printer, closure TransportClosure, src ocmcpi.ComponentVersionAccess, tgt ocmcpi.Repository, handler TransferHandler) error {
+	return TransferVersionWithContext(common.WithPrinter(context.Background(), common.AssurePrinter(printer)), closure, src, tgt, handler)
+}
+
+func TransferVersionWithContext(ctx context.Context, closure TransportClosure, src ocmcpi.ComponentVersionAccess, tgt ocmcpi.Repository, handler TransferHandler) error {
 	if closure == nil {
 		closure = TransportClosure{}
 	}
 	state := WalkingState{Closure: closure}
-	return transferVersion(common.AssurePrinter(printer), Logger(src), state, src, tgt, handler)
+	return transferVersion(ctx, Logger(src), state, src, tgt, handler)
 }
 
-func transferVersion(printer common.Printer, log logging.Logger, state WalkingState, src ocmcpi.ComponentVersionAccess, tgt ocmcpi.Repository, handler TransferHandler) (rerr error) {
+func transferVersion(ctx context.Context, log logging.Logger, state WalkingState, src ocmcpi.ComponentVersionAccess, tgt ocmcpi.Repository, handler TransferHandler) (rerr error) {
+	printer := common.GetPrinter(ctx)
+	if err := common.IsContextCanceled(ctx); err != nil {
+		printer.Printf("transfer cancelled by caller\n")
+		return err
+	}
 	nv := common.VersionedElementKey(src)
 	log = log.WithValues("history", state.History.String(), "version", nv)
 	if ok, err := state.Add(ocm.KIND_COMPONENTVERSION, nv); !ok {
@@ -155,7 +165,6 @@ func transferVersion(printer common.Printer, log logging.Logger, state WalkingSt
 		return errors.Wrapf(err, "%s: creating target version", state.History)
 	}
 
-	subp := printer.AddGap("  ")
 	list := errors.ErrListf("component references for %s", nv)
 	log.Info("  transferring references")
 	for _, r := range d.References {
@@ -164,7 +173,7 @@ func transferVersion(printer common.Printer, log logging.Logger, state WalkingSt
 			return errors.Wrapf(err, "%s: nested component %s[%s:%s]", state.History, r.GetName(), r.ComponentName, r.GetVersion())
 		}
 		if cv != nil {
-			list.Add(transferVersion(subp, log.WithValues("ref", r.Name), state, cv, tgt, shdlr))
+			list.Add(transferVersion(common.AddPrinterGap(ctx, "  "), log.WithValues("ref", r.Name), state, cv, tgt, shdlr))
 			list.Addf(nil, cv.Close(), "closing reference %s", r.Name)
 		}
 	}
@@ -196,7 +205,7 @@ func transferVersion(printer common.Printer, log logging.Logger, state WalkingSt
 		// corrupted content in target.
 		// If no copy is done, merge must keep the access methods in target!!!
 		if !doMerge || doCopy {
-			err = copyVersion(printer, log, state.History, src, t, n, handler)
+			err = copyVersion(ctx, printer, log, state.History, src, t, n, handler)
 			if err != nil {
 				return err
 			}
@@ -212,11 +221,15 @@ func transferVersion(printer common.Printer, log logging.Logger, state WalkingSt
 }
 
 func CopyVersion(printer common.Printer, log logging.Logger, hist common.History, src ocm.ComponentVersionAccess, t ocm.ComponentVersionAccess, handler TransferHandler) (rerr error) {
-	return copyVersion(common.AssurePrinter(printer), log, hist, src, t, src.GetDescriptor().Copy(), handler)
+	return copyVersion(context.Background(), common.AssurePrinter(printer), log, hist, src, t, src.GetDescriptor().Copy(), handler)
+}
+
+func CopyVersionWithContext(cctx context.Context, log logging.Logger, hist common.History, src ocm.ComponentVersionAccess, t ocm.ComponentVersionAccess, handler TransferHandler) (rerr error) {
+	return copyVersion(cctx, common.GetPrinter(cctx), log, hist, src, t, src.GetDescriptor().Copy(), handler)
 }
 
 // copyVersion (purely internal) expects an already prepared target comp desc for t given as prep.
-func copyVersion(printer common.Printer, log logging.Logger, hist common.History, src ocm.ComponentVersionAccess, t ocm.ComponentVersionAccess, prep *compdesc.ComponentDescriptor, handler TransferHandler) (rerr error) {
+func copyVersion(cctx context.Context, printer common.Printer, log logging.Logger, hist common.History, src ocm.ComponentVersionAccess, t ocm.ComponentVersionAccess, prep *compdesc.ComponentDescriptor, handler TransferHandler) (rerr error) {
 	var finalize finalizer.Finalizer
 
 	defer errors.PropagateError(&rerr, finalize.Finalize)
@@ -232,6 +245,11 @@ func copyVersion(printer common.Printer, log logging.Logger, hist common.History
 	for i, r := range src.GetResources() {
 		var m ocmcpi.AccessMethod
 
+		if err := common.IsContextCanceled(cctx); err != nil {
+			printer.Printf("cancelled by caller\n")
+			return err
+		}
+
 		nested := finalize.Nested()
 
 		a, err := r.Access()
@@ -295,6 +313,11 @@ func copyVersion(printer common.Printer, log logging.Logger, hist common.History
 	for i, r := range src.GetSources() {
 		var m ocmcpi.AccessMethod
 
+		if err := common.IsContextCanceled(cctx); err != nil {
+			printer.Printf("cancelled by caller\n")
+			return err
+		}
+
 		a, err := r.Access()
 		if err == nil {
 			m, err = a.AccessMethod(src)

api/ocm/tools/transfer/transferhandler/standard/handler_test.go

@@ -1,6 +1,7 @@
 package standard_test
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 
@@ -109,6 +110,26 @@ var _ = Describe("Transfer handler", func() {
 		env.Cleanup()
 	})
 
+	It("cancelled", func() {
+		src := Must(ctf.Open(env.OCMContext(), accessobj.ACC_WRITABLE, ARCH, 0, env))
+		defer Close(src, "source")
+		cv := Must(src.LookupComponentVersion(COMPONENT, VERSION))
+		defer Close(cv, "source cv")
+		tgt := Must(ctf.Create(env.OCMContext(), accessobj.ACC_WRITABLE|accessobj.ACC_CREATE, OUT, 0o700, accessio.FormatDirectory, env))
+		defer Close(tgt, "target")
+
+		// handler, err := standard.New(standard.ResourcesByValue())
+		p, buf := common.NewBufferedPrinter()
+		opts := []transferhandler.TransferOption{standard.ResourcesByValue(), &optionsChecker{}}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		ctx = common.WithPrinter(ctx, p)
+		cancel()
+		ExpectError(transfer.TransferWithContext(ctx, cv, tgt, opts...)).To(MatchError(context.Canceled))
+
+		Expect(buf.String()).To(Equal("transfer cancelled by caller\n"))
+	})
+
 	It("test", func() {
 		src := Must(ctf.Open(env.OCMContext(), accessobj.ACC_WRITABLE, ARCH, 0, env))
 		defer Close(src, "source")

api/utils/misc/context.go

@@ -0,0 +1,33 @@
+package misc
+
+import (
+	"context"
+	"reflect"
+)
+
+var printerKey = reflect.TypeOf(printer{})
+
+func WithPrinter(ctx context.Context, printer Printer) context.Context {
+	return context.WithValue(ctx, printerKey, AssurePrinter(printer))
+}
+
+func GetPrinter(ctx context.Context) Printer {
+	p := ctx.Value(printerKey)
+	if p == nil {
+		return NonePrinter
+	}
+	return p.(Printer)
+}
+
+func AddPrinterGap(ctx context.Context, gap string) context.Context {
+	return WithPrinter(ctx, GetPrinter(ctx).AddGap(gap))
+}
+
+func IsContextCanceled(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+		return nil
+	}
+}