consolidate CreateOrUpdateAsync params, solve for revive lint violations

Signed-off-by: Jack Francis <[email protected]>

Author: jackfrancis

azure/services/async/async.go

@@ -63,20 +63,19 @@ func (s *Service[C, D]) CreateOrUpdateResource(ctx context.Context, spec azure.R
 	futureType := infrav1.PutFuture
 
 	// Check if there is an ongoing long-running operation.
-	resumeToken := ""
+	createOrUpdateOpts := azure.CreateOrUpdateAsyncOpts{}
 	if future := s.Scope.GetLongRunningOperationState(resourceName, serviceName, futureType); future != nil {
 		t, err := converters.FutureToResumeToken(*future)
 		if err != nil {
 			s.Scope.DeleteLongRunningOperationState(resourceName, serviceName, futureType)
 			return "", errors.Wrap(err, "could not decode future data, resetting long-running operation state")
 		}
-		resumeToken = t
+		createOrUpdateOpts.ResumeToken = t
 	}
 
 	// Only when no long running operation is currently in progress do we need to get the parameters.
 	// The polling implemented by the SDK does not use parameters when a resume token exists.
-	var parameters interface{}
-	if resumeToken == "" {
+	if createOrUpdateOpts.ResumeToken == "" {
 		// Get the resource if it already exists, and use it to construct the desired resource parameters.
 		var existingResource interface{}
 		if existing, err := s.Creator.Get(ctx, spec); err != nil && !azure.ResourceNotFound(err) {
@@ -88,10 +87,10 @@ func (s *Service[C, D]) CreateOrUpdateResource(ctx context.Context, spec azure.R
 		}
 
 		// Construct parameters using the resource spec and information from the existing resource, if there is one.
-		parameters, err = spec.Parameters(ctx, existingResource)
+		createOrUpdateOpts.Parameters, err = spec.Parameters(ctx, existingResource)
 		if err != nil {
 			return nil, errors.Wrapf(err, "failed to get desired parameters for resource %s/%s (service: %s)", rgName, resourceName, serviceName)
-		} else if parameters == nil {
+		} else if createOrUpdateOpts.Parameters == nil {
 			// Nothing to do, don't create or update the resource and return the existing resource.
 			log.V(2).Info("resource up to date", "service", serviceName, "resource", resourceName, "resourceGroup", rgName)
 			return existingResource, nil
@@ -105,7 +104,7 @@ func (s *Service[C, D]) CreateOrUpdateResource(ctx context.Context, spec azure.R
 		}
 	}
 
-	result, poller, err := s.Creator.CreateOrUpdateAsync(ctx, spec, resumeToken, parameters)
+	result, poller, err := s.Creator.CreateOrUpdateAsync(ctx, spec, createOrUpdateOpts)
 	errWrapped := errors.Wrapf(err, "failed to create or update resource %s/%s (service: %s)", rgName, resourceName, serviceName)
 	if poller != nil && azure.IsContextDeadlineExceededOrCanceledError(err) {
 		future, err := converters.PollerToFuture(poller, infrav1.PutFuture, serviceName, resourceName, rgName)

azure/services/async/async_test.go

@@ -72,7 +72,7 @@ func TestServiceCreateOrUpdateResource(t *testing.T) {
 					r.ResourceName().Return(resourceName),
 					r.ResourceGroupName().Return(resourceGroupName),
 					s.GetLongRunningOperationState(resourceName, serviceName, infrav1.PutFuture).Return(validPutFuture),
-					c.CreateOrUpdateAsync(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType), resumeToken, gomock.Any()).Return(fakeResource, nil, nil),
+					c.CreateOrUpdateAsync(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType), createOrUpdateAsyncOpts).Return(fakeResource, nil, nil),
 					s.DeleteLongRunningOperationState(resourceName, serviceName, infrav1.PutFuture),
 				)
 			},
@@ -86,7 +86,7 @@ func TestServiceCreateOrUpdateResource(t *testing.T) {
 					r.ResourceName().Return(resourceName),
 					r.ResourceGroupName().Return(resourceGroupName),
 					s.GetLongRunningOperationState(resourceName, serviceName, infrav1.PutFuture).Return(validPutFuture),
-					c.CreateOrUpdateAsync(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType), resumeToken, gomock.Any()).Return(nil, fakePoller[MockCreator](g, http.StatusAccepted), context.DeadlineExceeded),
+					c.CreateOrUpdateAsync(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType), createOrUpdateAsyncOpts).Return(nil, fakePoller[MockCreator](g, http.StatusAccepted), context.DeadlineExceeded),
 					s.SetLongRunningOperationState(gomock.AssignableToTypeOf(&infrav1.Future{})),
 					s.DefaultedReconcilerRequeue().Return(reconciler.DefaultReconcilerRequeue),
 				)
@@ -101,7 +101,7 @@ func TestServiceCreateOrUpdateResource(t *testing.T) {
 					r.ResourceName().Return(resourceName),
 					r.ResourceGroupName().Return(resourceGroupName),
 					s.GetLongRunningOperationState(resourceName, serviceName, infrav1.PutFuture).Return(validPutFuture),
-					c.CreateOrUpdateAsync(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType), resumeToken, gomock.Any()).Return(nil, fakePoller[MockCreator](g, http.StatusAccepted), errors.New("foo")),
+					c.CreateOrUpdateAsync(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType), createOrUpdateAsyncOpts).Return(nil, fakePoller[MockCreator](g, http.StatusAccepted), errors.New("foo")),
 					s.DeleteLongRunningOperationState(resourceName, serviceName, infrav1.PutFuture),
 				)
 			},
@@ -117,7 +117,7 @@ func TestServiceCreateOrUpdateResource(t *testing.T) {
 					s.GetLongRunningOperationState(resourceName, serviceName, infrav1.PutFuture).Return(nil),
 					c.Get(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType)).Return(nil, &azcore.ResponseError{StatusCode: http.StatusNotFound}),
 					r.Parameters(gomockinternal.AContext(), nil).Return(fakeParameters, nil),
-					c.CreateOrUpdateAsync(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType), "", gomock.Any()).Return(nil, fakePoller[MockCreator](g, http.StatusAccepted), context.DeadlineExceeded),
+					c.CreateOrUpdateAsync(gomockinternal.AContext(), gomock.AssignableToTypeOf(azureResourceGetterType), gomock.Any()).Return(nil, fakePoller[MockCreator](g, http.StatusAccepted), context.DeadlineExceeded),
 					s.SetLongRunningOperationState(gomock.AssignableToTypeOf(&infrav1.Future{})),
 					s.DefaultedReconcilerRequeue().Return(reconciler.DefaultReconcilerRequeue),
 				)
@@ -293,17 +293,19 @@ const (
 	resourceGroupName  = "mock-resourcegroup"
 	resourceName       = "mock-resource"
 	serviceName        = "mock-service"
-	resumeToken        = "mock-resume-token"
 	invalidResumeToken = "!invalid-resume-token"
 )
 
 var (
+	createOrUpdateAsyncOpts = azure.CreateOrUpdateAsyncOpts{
+		ResumeToken: "mock-resume-token",
+	}
 	validPutFuture = &infrav1.Future{
 		Type:          infrav1.PutFuture,
 		ServiceName:   serviceName,
 		Name:          resourceName,
 		ResourceGroup: resourceGroupName,
-		Data:          base64.URLEncoding.EncodeToString([]byte(resumeToken)),
+		Data:          base64.URLEncoding.EncodeToString([]byte(createOrUpdateAsyncOpts.ResumeToken)),
 	}
 	invalidPutFuture = &infrav1.Future{
 		Type:          infrav1.PutFuture,
@@ -317,7 +319,7 @@ var (
 		ServiceName:   serviceName,
 		Name:          resourceName,
 		ResourceGroup: resourceGroupName,
-		Data:          base64.URLEncoding.EncodeToString([]byte(resumeToken)),
+		Data:          base64.URLEncoding.EncodeToString([]byte(createOrUpdateAsyncOpts.ResumeToken)),
 	}
 	invalidDeleteFuture = &infrav1.Future{
 		Type:          infrav1.DeleteFuture,

azure/services/async/interfaces.go

@@ -43,7 +43,7 @@ type TagsGetter interface {
 // Creator creates or updates a resource asynchronously.
 type Creator[T any] interface {
 	Getter
-	CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, resumeToken string, parameters interface{}) (result interface{}, poller *runtime.Poller[T], err error)
+	CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, opts azure.CreateOrUpdateAsyncOpts) (result interface{}, poller *runtime.Poller[T], err error)
 }
 
 // Deleter deletes a resource asynchronously.

azure/services/async/mock_async/async_mock.go

@@ -60,13 +60,13 @@ func (ac *AzureClient) Get(ctx context.Context, spec azure.ResourceSpecGetter) (
 // CreateOrUpdateAsync creates or updates an availability set asynchronously.
 // It sends a PUT request to Azure and if accepted without error, the func will return a Poller which can be used to track the ongoing
 // progress of the operation.
-func (ac *AzureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, _resumeToken string, parameters interface{}) (result interface{}, poller *runtime.Poller[armcompute.AvailabilitySetsClientCreateOrUpdateResponse], err error) { //nolint:revive // keeping _resumeToken for understanding purposes
+func (ac *AzureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, opts azure.CreateOrUpdateAsyncOpts) (result interface{}, poller *runtime.Poller[armcompute.AvailabilitySetsClientCreateOrUpdateResponse], err error) {
 	ctx, _, done := tele.StartSpanWithLogger(ctx, "availabilitySets.AzureClient.CreateOrUpdateAsync")
 	defer done()
 
-	availabilitySet, ok := parameters.(armcompute.AvailabilitySet)
-	if !ok && parameters != nil {
-		return nil, nil, errors.Errorf("%T is not an armcompute.AvailabilitySet", parameters)
+	availabilitySet, ok := opts.Parameters.(armcompute.AvailabilitySet)
+	if !ok && opts.Parameters != nil {
+		return nil, nil, errors.Errorf("%T is not an armcompute.AvailabilitySet", opts.Parameters)
 	}
 
 	// Note: there is no async `BeginCreateOrUpdate` implementation for availability sets, so this func will never return a poller.
@@ -82,7 +82,7 @@ func (ac *AzureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.Resou
 // DeleteAsync deletes a availability set asynchronously. DeleteAsync sends a DELETE
 // request to Azure and if accepted without error, the func will return a Poller which can be used to track the ongoing
 // progress of the operation.
-func (ac *AzureClient) DeleteAsync(ctx context.Context, spec azure.ResourceSpecGetter, _resumeToken string) (poller *runtime.Poller[armcompute.AvailabilitySetsClientDeleteResponse], err error) { //nolint:revive // keeping _resumeToken for understanding purposes
+func (ac *AzureClient) DeleteAsync(ctx context.Context, spec azure.ResourceSpecGetter, _ string) (poller *runtime.Poller[armcompute.AvailabilitySetsClientDeleteResponse], err error) {
 	ctx, _, done := tele.StartSpanWithLogger(ctx, "availabilitysets.AzureClient.DeleteAsync")
 	defer done()
 

azure/services/availabilitysets/client.go

@@ -90,18 +90,18 @@ func (ac *azureClient) List(ctx context.Context, resourceGroupName, lbName strin
 // CreateOrUpdateAsync creates or updates an inbound NAT rule asynchronously.
 // It sends a PUT request to Azure and if accepted without error, the func will return a Poller which can be used to track the ongoing
 // progress of the operation.
-func (ac *azureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, resumeToken string, parameters interface{}) (result interface{}, poller *runtime.Poller[armnetwork.InboundNatRulesClientCreateOrUpdateResponse], err error) {
+func (ac *azureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, opts azure.CreateOrUpdateAsyncOpts) (result interface{}, poller *runtime.Poller[armnetwork.InboundNatRulesClientCreateOrUpdateResponse], err error) {
 	ctx, log, done := tele.StartSpanWithLogger(ctx, "inboundnatrules.azureClient.CreateOrUpdateAsync")
 	defer done()
 
-	natRule, ok := parameters.(armnetwork.InboundNatRule)
-	if !ok && parameters != nil {
-		return nil, nil, errors.Errorf("%T is not an armnetwork.InboundNatRule", parameters)
+	natRule, ok := opts.Parameters.(armnetwork.InboundNatRule)
+	if !ok && opts.Parameters != nil {
+		return nil, nil, errors.Errorf("%T is not an armnetwork.InboundNatRule", opts.Parameters)
 	}
 
-	opts := &armnetwork.InboundNatRulesClientBeginCreateOrUpdateOptions{ResumeToken: resumeToken}
-	log.V(4).Info("sending request", "resumeToken", resumeToken)
-	poller, err = ac.inboundnatrules.BeginCreateOrUpdate(ctx, spec.ResourceGroupName(), spec.OwnerResourceName(), spec.ResourceName(), natRule, opts)
+	beginOpts := &armnetwork.InboundNatRulesClientBeginCreateOrUpdateOptions{ResumeToken: opts.ResumeToken}
+	log.V(4).Info("sending request", "resumeToken", opts.ResumeToken)
+	poller, err = ac.inboundnatrules.BeginCreateOrUpdate(ctx, spec.ResourceGroupName(), spec.OwnerResourceName(), spec.ResourceName(), natRule, beginOpts)
 	if err != nil {
 		return nil, nil, err
 	}

azure/services/inboundnatrules/client.go

@@ -67,13 +67,13 @@ func (ac *azureClient) Get(ctx context.Context, spec azure.ResourceSpecGetter) (
 // CreateOrUpdateAsync creates or updates a load balancer asynchronously.
 // It sends a PUT request to Azure and if accepted without error, the func will return a Poller which can be used to track the ongoing
 // progress of the operation.
-func (ac *azureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, resumeToken string, parameters interface{}) (result interface{}, poller *runtime.Poller[armnetwork.LoadBalancersClientCreateOrUpdateResponse], err error) {
+func (ac *azureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, opts azure.CreateOrUpdateAsyncOpts) (result interface{}, poller *runtime.Poller[armnetwork.LoadBalancersClientCreateOrUpdateResponse], err error) {
 	ctx, _, done := tele.StartSpanWithLogger(ctx, "loadbalancers.azureClient.CreateOrUpdate")
 	defer done()
 
-	loadBalancer, ok := parameters.(armnetwork.LoadBalancer)
-	if !ok && parameters != nil {
-		return nil, nil, errors.Errorf("%T is not an armnetwork.LoadBalancer", parameters)
+	loadBalancer, ok := opts.Parameters.(armnetwork.LoadBalancer)
+	if !ok && opts.Parameters != nil {
+		return nil, nil, errors.Errorf("%T is not an armnetwork.LoadBalancer", opts.Parameters)
 	}
 
 	var extraPolicies []policy.Policy
@@ -97,8 +97,8 @@ func (ac *azureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.Resou
 	}
 
 	client := factory.NewLoadBalancersClient()
-	opts := &armnetwork.LoadBalancersClientBeginCreateOrUpdateOptions{ResumeToken: resumeToken}
-	poller, err = client.BeginCreateOrUpdate(ctx, spec.ResourceGroupName(), spec.ResourceName(), loadBalancer, opts)
+	beginOpts := &armnetwork.LoadBalancersClientBeginCreateOrUpdateOptions{ResumeToken: opts.ResumeToken}
+	poller, err = client.BeginCreateOrUpdate(ctx, spec.ResourceGroupName(), spec.ResourceName(), loadBalancer, beginOpts)
 	if err != nil {
 		return nil, nil, err
 	}

azure/services/loadbalancers/client.go

@@ -36,7 +36,7 @@ type azureClient struct {
 }
 
 // NewClient creates a new network interfaces client from an authorizer.
-func NewClient(auth azure.Authorizer, apiCallTimeout time.Duration) (*azureClient, error) { //nolint:revive // leave it as is
+func NewClient(auth azure.Authorizer, apiCallTimeout time.Duration) (*azureClient, error) {
 	opts, err := azure.ARMClientOptions(auth.CloudEnvironment())
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to create networkinterfaces client options")
@@ -63,17 +63,17 @@ func (ac *azureClient) Get(ctx context.Context, spec azure.ResourceSpecGetter) (
 // CreateOrUpdateAsync creates or updates a network interface asynchronously.
 // It sends a PUT request to Azure and if accepted without error, the func will return a poller which can be used to track the ongoing
 // progress of the operation.
-func (ac *azureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, resumeToken string, parameters interface{}) (result interface{}, poller *runtime.Poller[armnetwork.InterfacesClientCreateOrUpdateResponse], err error) {
+func (ac *azureClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, opts azure.CreateOrUpdateAsyncOpts) (result interface{}, poller *runtime.Poller[armnetwork.InterfacesClientCreateOrUpdateResponse], err error) {
 	ctx, _, done := tele.StartSpanWithLogger(ctx, "networkinterfaces.AzureClient.CreateOrUpdateAsync")
 	defer done()
 
-	networkInterface, ok := parameters.(armnetwork.Interface)
-	if !ok && parameters != nil {
-		return nil, nil, errors.Errorf("%T is not an armnetwork.Interface", parameters)
+	networkInterface, ok := opts.Parameters.(armnetwork.Interface)
+	if !ok && opts.Parameters != nil {
+		return nil, nil, errors.Errorf("%T is not an armnetwork.Interface", opts.Parameters)
 	}
 
-	opts := &armnetwork.InterfacesClientBeginCreateOrUpdateOptions{ResumeToken: resumeToken}
-	poller, err = ac.interfaces.BeginCreateOrUpdate(ctx, spec.ResourceGroupName(), spec.ResourceName(), networkInterface, opts)
+	beginOpts := &armnetwork.InterfacesClientBeginCreateOrUpdateOptions{ResumeToken: opts.ResumeToken}
+	poller, err = ac.interfaces.BeginCreateOrUpdate(ctx, spec.ResourceGroupName(), spec.ResourceName(), networkInterface, beginOpts)
 	if err != nil {
 		return nil, nil, err
 	}

azure/services/networkinterfaces/client.go

@@ -63,17 +63,17 @@ func (avc *azureVirtualNetworkLinksClient) Get(ctx context.Context, spec azure.R
 // CreateOrUpdateAsync creates or updates a virtual network link asynchronously.
 // It sends a PUT request to Azure and if accepted without error, the func will return a poller which can be used to track the ongoing
 // progress of the operation.
-func (avc *azureVirtualNetworkLinksClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, resumeToken string, parameters interface{}) (result interface{}, poller *runtime.Poller[armprivatedns.VirtualNetworkLinksClientCreateOrUpdateResponse], err error) {
+func (avc *azureVirtualNetworkLinksClient) CreateOrUpdateAsync(ctx context.Context, spec azure.ResourceSpecGetter, opts azure.CreateOrUpdateAsyncOpts) (result interface{}, poller *runtime.Poller[armprivatedns.VirtualNetworkLinksClientCreateOrUpdateResponse], err error) {
 	ctx, _, done := tele.StartSpanWithLogger(ctx, "privatedns.azureVirtualNetworkLinksClient.CreateOrUpdateAsync")
 	defer done()
 
-	link, ok := parameters.(armprivatedns.VirtualNetworkLink)
-	if !ok && parameters != nil {
-		return nil, nil, errors.Errorf("%T is not an armprivatedns.VirtualNetworkLink", parameters)
+	link, ok := opts.Parameters.(armprivatedns.VirtualNetworkLink)
+	if !ok && opts.Parameters != nil {
+		return nil, nil, errors.Errorf("%T is not an armprivatedns.VirtualNetworkLink", opts.Parameters)
 	}
 
-	opts := &armprivatedns.VirtualNetworkLinksClientBeginCreateOrUpdateOptions{ResumeToken: resumeToken}
-	poller, err = avc.vnetlinks.BeginCreateOrUpdate(ctx, spec.ResourceGroupName(), spec.OwnerResourceName(), spec.ResourceName(), link, opts)
+	beginOpts := &armprivatedns.VirtualNetworkLinksClientBeginCreateOrUpdateOptions{ResumeToken: opts.ResumeToken}
+	poller, err = avc.vnetlinks.BeginCreateOrUpdate(ctx, spec.ResourceGroupName(), spec.OwnerResourceName(), spec.ResourceName(), link, beginOpts)
 	if err != nil {
 		return nil, nil, err
 	}