replace deprecated k8s.io/apimachinery/pkg/util/wait funcs

cadenmarchese · mociarain · commit 3711bf3be36e · 2026-01-26T15:00:37.000+01:00
diff --git a/pkg/cluster/delete.go b/pkg/cluster/delete.go
@@ -347,13 +347,13 @@ func (m *manager) deleteGatewayAndWait(ctx context.Context) error {
 	}
 
 	m.log.Info("waiting for gateway record deletion")
-	return wait.PollImmediateUntil(15*time.Second, func() (bool, error) {
+	return wait.PollUntilContextCancel(timeoutCtx, 15*time.Second, true, func(ctx context.Context) (bool, error) {
 		_, err := m.dbGateway.Get(ctx, m.doc.OpenShiftCluster.Properties.NetworkProfile.GatewayPrivateLinkID)
 		if err != nil && cosmosdb.IsErrorStatusCode(err, http.StatusNotFound) /* already gone */ {
 			return true, nil
 		}
 		return false, nil
-	}, timeoutCtx.Done())
+	})
 }
 
 func (m *manager) deleteGateway(ctx context.Context) error {
diff --git a/pkg/cluster/deploybaseresources.go b/pkg/cluster/deploybaseresources.go
@@ -362,7 +362,7 @@ func (m *manager) _attachNSGs(ctx context.Context, timeout time.Duration, pollIn
 	// NSG since the inner loop is tolerant of that, and since we are attaching
 	// the same NSG the only allowed failure case is when the NSG cannot be
 	// attached to begin with, so it shouldn't happen in practice.
-	_ = wait.PollImmediateUntil(pollInterval, func() (bool, error) {
+	_ = wait.PollUntilContextCancel(timeoutCtx, pollInterval, true, func(pollCtx context.Context) (bool, error) {
 		var c bool
 		c, innerErr = func() (bool, error) {
 			for _, subnetID := range []string{
@@ -427,7 +427,7 @@ func (m *manager) _attachNSGs(ctx context.Context, timeout time.Duration, pollIn
 		}()
 
 		return c, innerErr
-	}, timeoutCtx.Done())
+	})
 
 	return innerErr
 }
diff --git a/pkg/deploy/predeploy.go b/pkg/deploy/predeploy.go
@@ -589,9 +589,9 @@ func (d *deployer) restartOldScaleset(ctx context.Context, vmssName string, lbHe
 }
 
 func (d *deployer) waitForReadiness(ctx context.Context, vmssName string, vmInstanceID string) error {
-	return wait.PollImmediateUntil(10*time.Second, func() (bool, error) {
+	return wait.PollUntilContextCancel(ctx, 10*time.Second, true, func(pollCtx context.Context) (bool, error) {
 		return d.isVMInstanceHealthy(ctx, d.config.RPResourceGroupName, vmssName, vmInstanceID), nil
-	}, ctx.Done())
+	})
 }
 
 func (d *deployer) isVMInstanceHealthy(ctx context.Context, resourceGroupName string, vmssName string, vmInstanceID string) bool {
diff --git a/pkg/deploy/upgrade_gateway.go b/pkg/deploy/upgrade_gateway.go
@@ -43,15 +43,15 @@ func (d *deployer) gatewayWaitForReadiness(ctx context.Context, vmssName string)
 	}
 
 	d.log.Printf("waiting for %s instances to be healthy", vmssName)
-	return wait.PollImmediateUntil(10*time.Second, func() (bool, error) {
+	return wait.PollUntilContextCancel(ctx, 10*time.Second, true, func(pollCtx context.Context) (bool, error) {
 		for _, vm := range scalesetVMs {
 			if !d.isVMInstanceHealthy(ctx, d.config.GatewayResourceGroupName, vmssName, *vm.InstanceID) {
 				return false, nil
 			}
 		}
 
 		return true, nil
-	}, ctx.Done())
+	})
 }
 
 func (d *deployer) gatewayRemoveOldScalesets(ctx context.Context) error {
diff --git a/pkg/deploy/upgrade_rp.go b/pkg/deploy/upgrade_rp.go
@@ -43,15 +43,15 @@ func (d *deployer) rpWaitForReadiness(ctx context.Context, vmssName string) erro
 	}
 
 	d.log.Printf("waiting for %s instances to be healthy", vmssName)
-	return wait.PollImmediateUntil(10*time.Second, func() (bool, error) {
+	return wait.PollUntilContextCancel(ctx, 10*time.Second, true, func(pollCtx context.Context) (bool, error) {
 		for _, vm := range scalesetVMs {
 			if !d.isVMInstanceHealthy(ctx, d.config.RPResourceGroupName, vmssName, *vm.InstanceID) {
 				return false, nil
 			}
 		}
 
 		return true, nil
-	}, ctx.Done())
+	})
 }
 
 func (d *deployer) rpRemoveOldScalesets(ctx context.Context) error {
diff --git a/pkg/operator/controllers/guardrails/guardrails_controller.go b/pkg/operator/controllers/guardrails/guardrails_controller.go
@@ -99,9 +99,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.
 		timeoutCtx, cancel := context.WithTimeout(ctx, r.readinessTimeout)
 		defer cancel()
 
-		err := wait.PollImmediateUntil(r.readinessPollTime, func() (bool, error) {
+		err := wait.PollUntilContextCancel(timeoutCtx, r.readinessPollTime, true, func(pollCtx context.Context) (bool, error) {
 			return r.gatekeeperDeploymentIsReady(ctx, deployConfig)
-		}, timeoutCtx.Done())
+		})
 		if err != nil {
 			return reconcile.Result{}, fmt.Errorf("GateKeeper deployment timed out on Ready: %w", err)
 		}
@@ -114,9 +114,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.
 				return reconcile.Result{}, err
 			}
 
-			err := wait.PollImmediateUntil(r.readinessPollTime, func() (bool, error) {
+			err := wait.PollUntilContextCancel(timeoutCtx, r.readinessPollTime, true, func(pollCtx context.Context) (bool, error) {
 				return r.gkPolicyTemplate.IsConstraintTemplateReady(ctx, policyConfig)
-			}, timeoutCtx.Done())
+			})
 			if err != nil {
 				return reconcile.Result{}, fmt.Errorf("GateKeeper ConstraintTemplates timed out on creation: %w", err)
 			}
diff --git a/pkg/operator/controllers/muo/muo_controller.go b/pkg/operator/controllers/muo/muo_controller.go
@@ -114,9 +114,9 @@ func (r *Reconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.
 		timeoutCtx, cancel := context.WithTimeout(ctx, r.readinessTimeout)
 		defer cancel()
 
-		err = wait.PollImmediateUntil(r.readinessPollTime, func() (bool, error) {
+		err = wait.PollUntilContextCancel(timeoutCtx, r.readinessPollTime, true, func(pollCtx context.Context) (bool, error) {
 			return r.deployer.IsReady(ctx, "openshift-managed-upgrade-operator", "managed-upgrade-operator")
-		}, timeoutCtx.Done())
+		})
 		if err != nil {
 			return reconcile.Result{}, fmt.Errorf("managed Upgrade Operator deployment timed out on Ready: %w", err)
 		}
diff --git a/pkg/operator/deploy/deploy.go b/pkg/operator/deploy/deploy.go
@@ -432,7 +432,7 @@ func (o *operator) applyDeployment(ctx context.Context, resources []kruntime.Obj
 				return err
 			}
 
-			err = wait.PollImmediate(time.Second, time.Minute, func() (bool, error) {
+			err = wait.PollUntilContextTimeout(ctx, time.Second, time.Minute, true, func(pollCtx context.Context) (bool, error) {
 				crd, err := o.extensionscli.ApiextensionsV1().CustomResourceDefinitions().Get(ctx, acc.GetName(), metav1.GetOptions{})
 				if err != nil {
 					return false, err
diff --git a/pkg/util/arm/deploy_test.go b/pkg/util/arm/deploy_test.go
@@ -74,7 +74,7 @@ func TestDeployARMTemplate(t *testing.T) {
 					Return(activeErr)
 				dc.EXPECT().
 					Wait(ctx, resourceGroup, deploymentName).
-					Return(wait.ErrWaitTimeout)
+					Return(wait.ErrorInterrupted(context.DeadlineExceeded))
 			},
 			wantErr: "timed out waiting for the condition",
 		},
diff --git a/pkg/util/azureclient/azuresdk/azcertificates/helpers.go b/pkg/util/azureclient/azuresdk/azcertificates/helpers.go
@@ -107,14 +107,14 @@ func WaitForCertificateOperation(parent context.Context, log *logrus.Entry, oper
 	ctx, cancel := context.WithTimeout(parent, 15*time.Minute)
 	defer cancel()
 
-	err := wait.PollImmediateUntil(10*time.Second, func() (bool, error) {
+	err := wait.PollUntilContextCancel(ctx, 10*time.Second, true, func(pollCtx context.Context) (bool, error) {
 		op, err := operation(ctx)
 		if err != nil {
 			return false, err
 		}
 
 		return checkOperation(op, log)
-	}, ctx.Done())
+	})
 	return err
 }
 
diff --git a/pkg/util/azureclient/mgmt/features/deployments_addons.go b/pkg/util/azureclient/mgmt/features/deployments_addons.go
@@ -48,7 +48,7 @@ func (c *deploymentsClient) DeleteAndWait(ctx context.Context, resourceGroupName
 }
 
 func (c *deploymentsClient) Wait(ctx context.Context, resourceGroupName string, deploymentName string) error {
-	return wait.Poll(c.PollingDelay, c.PollingDuration, func() (bool, error) {
+	return wait.PollUntilContextTimeout(ctx, c.PollingDelay, c.PollingDuration, false, func(pollCtx context.Context) (bool, error) {
 		deployment, err := c.Get(ctx, resourceGroupName, deploymentName)
 		if err != nil {
 			return false, err
diff --git a/pkg/util/cluster/aad.go b/pkg/util/cluster/aad.go
@@ -51,9 +51,9 @@ func (c *Cluster) createServicePrincipal(ctx context.Context, appID string) (str
 	defer cancel()
 
 	// NOTE: Do not override err with the error returned by
-	// wait.PollImmediateUntil. Doing this will not propagate the latest error
+	// wait.PollUntilContextCancel. Doing this will not propagate the latest error
 	// to the user in case when wait exceeds the timeout
-	_ = wait.PollImmediateUntil(10*time.Second, func() (bool, error) {
+	_ = wait.PollUntilContextCancel(timeoutCtx, 10*time.Second, true, func(pollCtx context.Context) (bool, error) {
 		requestBody := msgraph_models.NewServicePrincipal()
 		requestBody.SetAppId(&appID)
 		result, err = c.spGraphClient.ServicePrincipals().Post(ctx, requestBody, nil)
@@ -73,7 +73,7 @@ func (c *Cluster) createServicePrincipal(ctx context.Context, appID string) (str
 			return false, nil
 		}
 		return err == nil, err
-	}, timeoutCtx.Done())
+	})
 	if err != nil {
 		return "", err
 	}
diff --git a/pkg/util/cluster/cluster.go b/pkg/util/cluster/cluster.go
@@ -1243,11 +1243,11 @@ func (c *Cluster) fixupNSGs(ctx context.Context, vnetResourceGroup, clusterName
 	// very occasionally c.securitygroups.List returns an empty list in
 	// production.  No idea why.  Let's try retrying it...
 	var nsgs []*sdknetwork.SecurityGroup
-	err := wait.PollImmediateUntil(10*time.Second, func() (bool, error) {
+	err := wait.PollUntilContextCancel(timeoutCtx, 10*time.Second, true, func(ctx context.Context) (bool, error) {
 		var err error
 		nsgs, err = c.securitygroups.List(ctx, "aro-"+clusterName, nil)
 		return len(nsgs) > 0, err
-	}, timeoutCtx.Done())
+	})
 	if err != nil {
 		return err
 	}
@@ -1365,14 +1365,14 @@ func (c *Cluster) ensureResourceGroupDeleted(ctx context.Context, resourceGroupN
 	timeoutCtx, cancel := context.WithTimeout(ctx, 10*time.Minute)
 	defer cancel()
 
-	return wait.PollImmediateUntil(5*time.Second, func() (bool, error) {
+	return wait.PollUntilContextCancel(timeoutCtx, 5*time.Second, true, func(ctx context.Context) (bool, error) {
 		_, err := c.groups.Get(ctx, resourceGroupName)
 		if azureerrors.ResourceGroupNotFound(err) {
 			c.log.Infof("finished deleting resource group %s", resourceGroupName)
 			return true, nil
 		}
 		return false, fmt.Errorf("failed to delete resource group %s with %s", resourceGroupName, err)
-	}, timeoutCtx.Done())
+	})
 }
 
 func (c *Cluster) deleteResourceGroup(ctx context.Context, resourceGroup string) error {
diff --git a/pkg/util/steps/condition.go b/pkg/util/steps/condition.go
@@ -5,7 +5,6 @@ package steps
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"net/http"
 	"strings"
@@ -80,26 +79,26 @@ func (c conditionStep) run(ctx context.Context, log *logrus.Entry) error {
 	// Run the condition function immediately, and then every
 	// runner.pollInterval, until the condition returns true or timeoutCtx's
 	// timeout fires. Errors from `f` are returned directly unless the error
-	// is ErrWaitTimeout. Internal ErrWaitTimeout errors are wrapped to avoid
-	// confusion with wait.PollImmediateUntil's own behavior of returning
-	// ErrWaitTimeout when the condition is not met.
-	err := wait.PollImmediateUntil(pollInterval, func() (bool, error) {
+	// indicates a timeout. Internal timeout errors are wrapped to avoid
+	// confusion with wait.PollUntilContextCancel's own behavior of returning
+	// a timeout error when the condition is not met.
+	err := wait.PollUntilContextCancel(timeoutCtx, pollInterval, true, func(pollCtx context.Context) (bool, error) {
 		// We use the outer context, not the timeout context, as we do not want
 		// to time out the condition function itself, only stop retrying once
 		// timeoutCtx's timeout has fired.
 		cnd, cndErr := c.f(ctx)
-		if errors.Is(cndErr, wait.ErrWaitTimeout) {
+		if wait.Interrupted(cndErr) {
 			return cnd, fmt.Errorf("condition encountered internal timeout: %w", cndErr)
 		}
 
 		return cnd, cndErr
-	}, timeoutCtx.Done())
+	})
 
 	if err != nil && !c.fail {
 		log.Warnf("step %s failed but has configured 'fail=%t'. Continuing. Error: %s", c, c.fail, err.Error())
 		return nil
 	}
-	if errors.Is(err, wait.ErrWaitTimeout) {
+	if wait.Interrupted(err) {
 		return enrichConditionTimeoutError(c.f, err)
 	}
 	return err
diff --git a/pkg/util/steps/refreshing.go b/pkg/util/steps/refreshing.go
@@ -66,8 +66,8 @@ func (s *authorizationRefreshingActionStep) run(ctx context.Context, log *logrus
 	defer cancel()
 
 	// Propagate the latest authorization error to the user,
-	// rather than timeout error from PollImmediateUntil.
-	_ = wait.PollImmediateUntil(pollInterval, func() (bool, error) {
+	// rather than timeout error from PollUntilContextCancel.
+	_ = wait.PollUntilContextCancel(timeoutCtx, pollInterval, true, func(pollCtx context.Context) (bool, error) {
 		// We use the outer context, not the timeout context, as we do not want
 		// to time out the condition function itself, only stop retrying once
 		// timeoutCtx's timeout has fired.
@@ -91,7 +91,7 @@ func (s *authorizationRefreshingActionStep) run(ctx context.Context, log *logrus
 			log.Printf("non-auth error, giving up: %v", err)
 		}
 		return true, err
-	}, timeoutCtx.Done())
+	})
 
 	return CreateActionableError(err)
 }
diff --git a/pkg/util/steps/runner_test.go b/pkg/util/steps/runner_test.go
@@ -41,7 +41,7 @@ func timingOutCondition(ctx context.Context) (bool, error) {
 	return false, nil
 }
 func internalTimeoutCondition(ctx context.Context) (bool, error) {
-	return false, wait.ErrWaitTimeout
+	return false, wait.ErrorInterrupted(context.Canceled)
 }
 
 func currentTimeFunc() time.Time {
diff --git a/pkg/validate/dynamic/diskencryptionset.go b/pkg/validate/dynamic/diskencryptionset.go
@@ -79,7 +79,7 @@ func (dv *dynamic) validateDiskEncryptionSetPermissions(ctx context.Context, des
 		"Microsoft.Compute/diskEncryptionSets/read",
 	})
 
-	if err == wait.ErrWaitTimeout {
+	if wait.Interrupted(err) {
 		if dv.authorizerType == AuthorizerWorkloadIdentity {
 			return api.NewCloudError(http.StatusBadRequest, api.CloudErrorCodeInvalidWorkloadIdentityPermissions, path, fmt.Sprintf("The %s platform managed identity does not have required permissions on disk encryption set '%s'.", *operatorName, desr.String()))
 		}
diff --git a/pkg/validate/dynamic/dynamic.go b/pkg/validate/dynamic/dynamic.go
@@ -303,7 +303,7 @@ func (dv *dynamic) validateVnetPermissions(ctx context.Context, vnet azure.Resou
 		}
 	}
 
-	if err == wait.ErrWaitTimeout {
+	if wait.Interrupted(err) {
 		return noPermissionsErr
 	}
 	if detailedErr, ok := err.(autorest.DetailedError); ok {
@@ -392,7 +392,7 @@ func (dv *dynamic) validateSubnetPermissions(ctx context.Context, s Subnet) erro
 		}
 	}
 
-	if err == wait.ErrWaitTimeout {
+	if wait.Interrupted(err) {
 		return noPermissionsErr
 	}
 	if detailedErr, ok := err.(autorest.DetailedError); ok {
@@ -471,7 +471,7 @@ func (dv *dynamic) validateRouteTablePermissions(ctx context.Context, s Subnet)
 
 	operatorName, err := dv.validateActions(ctx, &rtr, actionsToValidate)
 
-	if err == wait.ErrWaitTimeout {
+	if wait.Interrupted(err) {
 		if dv.authorizerType == AuthorizerWorkloadIdentity {
 			return api.NewCloudError(
 				http.StatusBadRequest,
@@ -562,7 +562,7 @@ func (dv *dynamic) validateNatGatewayPermissions(ctx context.Context, s Subnet)
 
 	operatorName, err := dv.validateActions(ctx, &ngr, actionsToValidate)
 
-	if err == wait.ErrWaitTimeout {
+	if wait.Interrupted(err) {
 		if dv.authorizerType == AuthorizerWorkloadIdentity {
 			return api.NewCloudError(
 				http.StatusBadRequest,
@@ -609,10 +609,12 @@ func (dv *dynamic) validateActionsByOID(ctx context.Context, r *azure.Resource,
 
 	c := closure{dv: dv, ctx: ctx, resource: r, actions: actions, oid: oid}
 
-	return wait.PollImmediateUntil(30*time.Second, c.usingCheckAccessV2, timeoutCtx.Done())
+	return wait.PollUntilContextCancel(timeoutCtx, 30*time.Second, true, func(pollCtx context.Context) (bool, error) {
+		return c.usingCheckAccessV2()
+	})
 }
 
-// closure is the closure used in PollImmediateUntil's ConditionalFunc
+// closure is the closure used in PollUntilContextCancel's ConditionalFunc
 type closure struct {
 	dv       *dynamic
 	ctx      context.Context
@@ -1042,7 +1044,7 @@ func (dv *dynamic) validateNSGPermissions(ctx context.Context, nsgID string) err
 
 	operatorName, err := dv.validateActions(ctx, &nsg, actionsToValidate)
 
-	if err == wait.ErrWaitTimeout {
+	if wait.Interrupted(err) {
 		errCode := api.CloudErrorCodeInvalidResourceProviderPermissions
 		switch dv.authorizerType {
 		case AuthorizerClusterServicePrincipal:

Original file line number	Diff line number	Diff line change
`@@ -347,13 +347,13 @@ func (m *manager) deleteGatewayAndWait(ctx context.Context) error {`
`347`	`347`	`}`
`348`	`348`
`349`	`349`	`m.log.Info("waiting for gateway record deletion")`
`350`		`- return wait.PollImmediateUntil(15*time.Second, func() (bool, error) {`
	`350`	`+ return wait.PollUntilContextCancel(timeoutCtx, 15*time.Second, true, func(ctx context.Context) (bool, error) {`
`351`	`351`	`_, err := m.dbGateway.Get(ctx, m.doc.OpenShiftCluster.Properties.NetworkProfile.GatewayPrivateLinkID)`
`352`	`352`	`if err != nil && cosmosdb.IsErrorStatusCode(err, http.StatusNotFound) /* already gone */ {`
`353`	`353`	`return true, nil`
`354`	`354`	`}`
`355`	`355`	`return false, nil`
`356`		`- }, timeoutCtx.Done())`
	`356`	`+ })`
`357`	`357`	`}`
`358`	`358`
`359`	`359`	`func (m *manager) deleteGateway(ctx context.Context) error {`
Original file line number	Diff line number	Diff line change
`@@ -589,9 +589,9 @@ func (d *deployer) restartOldScaleset(ctx context.Context, vmssName string, lbHe`
`589`	`589`	`}`
`590`	`590`
`591`	`591`	`func (d *deployer) waitForReadiness(ctx context.Context, vmssName string, vmInstanceID string) error {`
`592`		`- return wait.PollImmediateUntil(10*time.Second, func() (bool, error) {`
	`592`	`+ return wait.PollUntilContextCancel(ctx, 10*time.Second, true, func(pollCtx context.Context) (bool, error) {`
`593`	`593`	`return d.isVMInstanceHealthy(ctx, d.config.RPResourceGroupName, vmssName, vmInstanceID), nil`
`594`		`- }, ctx.Done())`
	`594`	`+ })`
`595`	`595`	`}`
`596`	`596`
`597`	`597`	`func (d *deployer) isVMInstanceHealthy(ctx context.Context, resourceGroupName string, vmssName string, vmInstanceID string) bool {`
Original file line number	Diff line number	Diff line change
`@@ -43,15 +43,15 @@ func (d *deployer) gatewayWaitForReadiness(ctx context.Context, vmssName string)`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`d.log.Printf("waiting for %s instances to be healthy", vmssName)`
`46`		`- return wait.PollImmediateUntil(10*time.Second, func() (bool, error) {`
	`46`	`+ return wait.PollUntilContextCancel(ctx, 10*time.Second, true, func(pollCtx context.Context) (bool, error) {`
`47`	`47`	`for _, vm := range scalesetVMs {`
`48`	`48`	`if !d.isVMInstanceHealthy(ctx, d.config.GatewayResourceGroupName, vmssName, *vm.InstanceID) {`
`49`	`49`	`return false, nil`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`return true, nil`
`54`		`- }, ctx.Done())`
	`54`	`+ })`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`func (d *deployer) gatewayRemoveOldScalesets(ctx context.Context) error {`
Original file line number	Diff line number	Diff line change
`@@ -432,7 +432,7 @@ func (o *operator) applyDeployment(ctx context.Context, resources []kruntime.Obj`
`432`	`432`	`return err`
`433`	`433`	`}`
`434`	`434`
`435`		`- err = wait.PollImmediate(time.Second, time.Minute, func() (bool, error) {`
	`435`	`+ err = wait.PollUntilContextTimeout(ctx, time.Second, time.Minute, true, func(pollCtx context.Context) (bool, error) {`
`436`	`436`	`crd, err := o.extensionscli.ApiextensionsV1().CustomResourceDefinitions().Get(ctx, acc.GetName(), metav1.GetOptions{})`
`437`	`437`	`if err != nil {`
`438`	`438`	`return false, err`
Original file line number	Diff line number	Diff line change
`@@ -107,14 +107,14 @@ func WaitForCertificateOperation(parent context.Context, log *logrus.Entry, oper`
`107`	`107`	`ctx, cancel := context.WithTimeout(parent, 15*time.Minute)`
`108`	`108`	`defer cancel()`
`109`	`109`
`110`		`- err := wait.PollImmediateUntil(10*time.Second, func() (bool, error) {`
	`110`	`+ err := wait.PollUntilContextCancel(ctx, 10*time.Second, true, func(pollCtx context.Context) (bool, error) {`
`111`	`111`	`op, err := operation(ctx)`
`112`	`112`	`if err != nil {`
`113`	`113`	`return false, err`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`return checkOperation(op, log)`
`117`		`- }, ctx.Done())`
	`117`	`+ })`
`118`	`118`	`return err`
`119`	`119`	`}`
`120`	`120`