azurefirewalls.go

Documentation: github.com/Azure/azure-sdk-for-go/services/network/mgmt/2020-04-01/network

     1  package network
     2  
     3  // Copyright (c) Microsoft Corporation. All rights reserved.
     4  // Licensed under the MIT License. See License.txt in the project root for license information.
     5  //
     6  // Code generated by Microsoft (R) AutoRest Code Generator.
     7  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
     8  
     9  import (
    10  	"context"
    11  	"github.com/Azure/go-autorest/autorest"
    12  	"github.com/Azure/go-autorest/autorest/azure"
    13  	"github.com/Azure/go-autorest/autorest/validation"
    14  	"github.com/Azure/go-autorest/tracing"
    15  	"net/http"
    16  )
    17  
    18  // AzureFirewallsClient is the network Client
    19  type AzureFirewallsClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewAzureFirewallsClient creates an instance of the AzureFirewallsClient client.
    24  func NewAzureFirewallsClient(subscriptionID string) AzureFirewallsClient {
    25  	return NewAzureFirewallsClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewAzureFirewallsClientWithBaseURI creates an instance of the AzureFirewallsClient client using a custom endpoint.
    29  // Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    30  func NewAzureFirewallsClientWithBaseURI(baseURI string, subscriptionID string) AzureFirewallsClient {
    31  	return AzureFirewallsClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CreateOrUpdate creates or updates the specified Azure Firewall.
    35  // Parameters:
    36  // resourceGroupName - the name of the resource group.
    37  // azureFirewallName - the name of the Azure Firewall.
    38  // parameters - parameters supplied to the create or update Azure Firewall operation.
    39  func (client AzureFirewallsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, azureFirewallName string, parameters AzureFirewall) (result AzureFirewallsCreateOrUpdateFuture, err error) {
    40  	if tracing.IsEnabled() {
    41  		ctx = tracing.StartSpan(ctx, fqdn+"/AzureFirewallsClient.CreateOrUpdate")
    42  		defer func() {
    43  			sc := -1
    44  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    45  				sc = result.FutureAPI.Response().StatusCode
    46  			}
    47  			tracing.EndSpan(ctx, sc, err)
    48  		}()
    49  	}
    50  	if err := validation.Validate([]validation.Validation{
    51  		{TargetValue: azureFirewallName,
    52  			Constraints: []validation.Constraint{{Target: "azureFirewallName", Name: validation.MaxLength, Rule: 56, Chain: nil},
    53  				{Target: "azureFirewallName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
    54  		return result, validation.NewError("network.AzureFirewallsClient", "CreateOrUpdate", err.Error())
    55  	}
    56  
    57  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, azureFirewallName, parameters)
    58  	if err != nil {
    59  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "CreateOrUpdate", nil, "Failure preparing request")
    60  		return
    61  	}
    62  
    63  	result, err = client.CreateOrUpdateSender(req)
    64  	if err != nil {
    65  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "CreateOrUpdate", result.Response(), "Failure sending request")
    66  		return
    67  	}
    68  
    69  	return
    70  }
    71  
    72  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    73  func (client AzureFirewallsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, azureFirewallName string, parameters AzureFirewall) (*http.Request, error) {
    74  	pathParameters := map[string]interface{}{
    75  		"azureFirewallName": autorest.Encode("path", azureFirewallName),
    76  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    77  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    78  	}
    79  
    80  	const APIVersion = "2020-04-01"
    81  	queryParameters := map[string]interface{}{
    82  		"api-version": APIVersion,
    83  	}
    84  
    85  	parameters.Etag = nil
    86  	preparer := autorest.CreatePreparer(
    87  		autorest.AsContentType("application/json; charset=utf-8"),
    88  		autorest.AsPut(),
    89  		autorest.WithBaseURL(client.BaseURI),
    90  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/azureFirewalls/{azureFirewallName}", pathParameters),
    91  		autorest.WithJSON(parameters),
    92  		autorest.WithQueryParameters(queryParameters))
    93  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    94  }
    95  
    96  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
    97  // http.Response Body if it receives an error.
    98  func (client AzureFirewallsClient) CreateOrUpdateSender(req *http.Request) (future AzureFirewallsCreateOrUpdateFuture, err error) {
    99  	var resp *http.Response
   100  	future.FutureAPI = &azure.Future{}
   101  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   102  	if err != nil {
   103  		return
   104  	}
   105  	var azf azure.Future
   106  	azf, err = azure.NewFutureFromResponse(resp)
   107  	future.FutureAPI = &azf
   108  	future.Result = future.result
   109  	return
   110  }
   111  
   112  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   113  // closes the http.Response Body.
   114  func (client AzureFirewallsClient) CreateOrUpdateResponder(resp *http.Response) (result AzureFirewall, err error) {
   115  	err = autorest.Respond(
   116  		resp,
   117  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   118  		autorest.ByUnmarshallingJSON(&result),
   119  		autorest.ByClosing())
   120  	result.Response = autorest.Response{Response: resp}
   121  	return
   122  }
   123  
   124  // Delete deletes the specified Azure Firewall.
   125  // Parameters:
   126  // resourceGroupName - the name of the resource group.
   127  // azureFirewallName - the name of the Azure Firewall.
   128  func (client AzureFirewallsClient) Delete(ctx context.Context, resourceGroupName string, azureFirewallName string) (result AzureFirewallsDeleteFuture, err error) {
   129  	if tracing.IsEnabled() {
   130  		ctx = tracing.StartSpan(ctx, fqdn+"/AzureFirewallsClient.Delete")
   131  		defer func() {
   132  			sc := -1
   133  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   134  				sc = result.FutureAPI.Response().StatusCode
   135  			}
   136  			tracing.EndSpan(ctx, sc, err)
   137  		}()
   138  	}
   139  	req, err := client.DeletePreparer(ctx, resourceGroupName, azureFirewallName)
   140  	if err != nil {
   141  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "Delete", nil, "Failure preparing request")
   142  		return
   143  	}
   144  
   145  	result, err = client.DeleteSender(req)
   146  	if err != nil {
   147  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "Delete", result.Response(), "Failure sending request")
   148  		return
   149  	}
   150  
   151  	return
   152  }
   153  
   154  // DeletePreparer prepares the Delete request.
   155  func (client AzureFirewallsClient) DeletePreparer(ctx context.Context, resourceGroupName string, azureFirewallName string) (*http.Request, error) {
   156  	pathParameters := map[string]interface{}{
   157  		"azureFirewallName": autorest.Encode("path", azureFirewallName),
   158  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   159  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   160  	}
   161  
   162  	const APIVersion = "2020-04-01"
   163  	queryParameters := map[string]interface{}{
   164  		"api-version": APIVersion,
   165  	}
   166  
   167  	preparer := autorest.CreatePreparer(
   168  		autorest.AsDelete(),
   169  		autorest.WithBaseURL(client.BaseURI),
   170  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/azureFirewalls/{azureFirewallName}", pathParameters),
   171  		autorest.WithQueryParameters(queryParameters))
   172  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   173  }
   174  
   175  // DeleteSender sends the Delete request. The method will close the
   176  // http.Response Body if it receives an error.
   177  func (client AzureFirewallsClient) DeleteSender(req *http.Request) (future AzureFirewallsDeleteFuture, err error) {
   178  	var resp *http.Response
   179  	future.FutureAPI = &azure.Future{}
   180  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   181  	if err != nil {
   182  		return
   183  	}
   184  	var azf azure.Future
   185  	azf, err = azure.NewFutureFromResponse(resp)
   186  	future.FutureAPI = &azf
   187  	future.Result = future.result
   188  	return
   189  }
   190  
   191  // DeleteResponder handles the response to the Delete request. The method always
   192  // closes the http.Response Body.
   193  func (client AzureFirewallsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   194  	err = autorest.Respond(
   195  		resp,
   196  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   197  		autorest.ByClosing())
   198  	result.Response = resp
   199  	return
   200  }
   201  
   202  // Get gets the specified Azure Firewall.
   203  // Parameters:
   204  // resourceGroupName - the name of the resource group.
   205  // azureFirewallName - the name of the Azure Firewall.
   206  func (client AzureFirewallsClient) Get(ctx context.Context, resourceGroupName string, azureFirewallName string) (result AzureFirewall, err error) {
   207  	if tracing.IsEnabled() {
   208  		ctx = tracing.StartSpan(ctx, fqdn+"/AzureFirewallsClient.Get")
   209  		defer func() {
   210  			sc := -1
   211  			if result.Response.Response != nil {
   212  				sc = result.Response.Response.StatusCode
   213  			}
   214  			tracing.EndSpan(ctx, sc, err)
   215  		}()
   216  	}
   217  	req, err := client.GetPreparer(ctx, resourceGroupName, azureFirewallName)
   218  	if err != nil {
   219  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "Get", nil, "Failure preparing request")
   220  		return
   221  	}
   222  
   223  	resp, err := client.GetSender(req)
   224  	if err != nil {
   225  		result.Response = autorest.Response{Response: resp}
   226  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "Get", resp, "Failure sending request")
   227  		return
   228  	}
   229  
   230  	result, err = client.GetResponder(resp)
   231  	if err != nil {
   232  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "Get", resp, "Failure responding to request")
   233  		return
   234  	}
   235  
   236  	return
   237  }
   238  
   239  // GetPreparer prepares the Get request.
   240  func (client AzureFirewallsClient) GetPreparer(ctx context.Context, resourceGroupName string, azureFirewallName string) (*http.Request, error) {
   241  	pathParameters := map[string]interface{}{
   242  		"azureFirewallName": autorest.Encode("path", azureFirewallName),
   243  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   244  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   245  	}
   246  
   247  	const APIVersion = "2020-04-01"
   248  	queryParameters := map[string]interface{}{
   249  		"api-version": APIVersion,
   250  	}
   251  
   252  	preparer := autorest.CreatePreparer(
   253  		autorest.AsGet(),
   254  		autorest.WithBaseURL(client.BaseURI),
   255  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/azureFirewalls/{azureFirewallName}", pathParameters),
   256  		autorest.WithQueryParameters(queryParameters))
   257  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   258  }
   259  
   260  // GetSender sends the Get request. The method will close the
   261  // http.Response Body if it receives an error.
   262  func (client AzureFirewallsClient) GetSender(req *http.Request) (*http.Response, error) {
   263  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   264  }
   265  
   266  // GetResponder handles the response to the Get request. The method always
   267  // closes the http.Response Body.
   268  func (client AzureFirewallsClient) GetResponder(resp *http.Response) (result AzureFirewall, err error) {
   269  	err = autorest.Respond(
   270  		resp,
   271  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   272  		autorest.ByUnmarshallingJSON(&result),
   273  		autorest.ByClosing())
   274  	result.Response = autorest.Response{Response: resp}
   275  	return
   276  }
   277  
   278  // List lists all Azure Firewalls in a resource group.
   279  // Parameters:
   280  // resourceGroupName - the name of the resource group.
   281  func (client AzureFirewallsClient) List(ctx context.Context, resourceGroupName string) (result AzureFirewallListResultPage, err error) {
   282  	if tracing.IsEnabled() {
   283  		ctx = tracing.StartSpan(ctx, fqdn+"/AzureFirewallsClient.List")
   284  		defer func() {
   285  			sc := -1
   286  			if result.aflr.Response.Response != nil {
   287  				sc = result.aflr.Response.Response.StatusCode
   288  			}
   289  			tracing.EndSpan(ctx, sc, err)
   290  		}()
   291  	}
   292  	result.fn = client.listNextResults
   293  	req, err := client.ListPreparer(ctx, resourceGroupName)
   294  	if err != nil {
   295  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "List", nil, "Failure preparing request")
   296  		return
   297  	}
   298  
   299  	resp, err := client.ListSender(req)
   300  	if err != nil {
   301  		result.aflr.Response = autorest.Response{Response: resp}
   302  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "List", resp, "Failure sending request")
   303  		return
   304  	}
   305  
   306  	result.aflr, err = client.ListResponder(resp)
   307  	if err != nil {
   308  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "List", resp, "Failure responding to request")
   309  		return
   310  	}
   311  	if result.aflr.hasNextLink() && result.aflr.IsEmpty() {
   312  		err = result.NextWithContext(ctx)
   313  		return
   314  	}
   315  
   316  	return
   317  }
   318  
   319  // ListPreparer prepares the List request.
   320  func (client AzureFirewallsClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
   321  	pathParameters := map[string]interface{}{
   322  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   323  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   324  	}
   325  
   326  	const APIVersion = "2020-04-01"
   327  	queryParameters := map[string]interface{}{
   328  		"api-version": APIVersion,
   329  	}
   330  
   331  	preparer := autorest.CreatePreparer(
   332  		autorest.AsGet(),
   333  		autorest.WithBaseURL(client.BaseURI),
   334  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/azureFirewalls", pathParameters),
   335  		autorest.WithQueryParameters(queryParameters))
   336  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   337  }
   338  
   339  // ListSender sends the List request. The method will close the
   340  // http.Response Body if it receives an error.
   341  func (client AzureFirewallsClient) ListSender(req *http.Request) (*http.Response, error) {
   342  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   343  }
   344  
   345  // ListResponder handles the response to the List request. The method always
   346  // closes the http.Response Body.
   347  func (client AzureFirewallsClient) ListResponder(resp *http.Response) (result AzureFirewallListResult, err error) {
   348  	err = autorest.Respond(
   349  		resp,
   350  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   351  		autorest.ByUnmarshallingJSON(&result),
   352  		autorest.ByClosing())
   353  	result.Response = autorest.Response{Response: resp}
   354  	return
   355  }
   356  
   357  // listNextResults retrieves the next set of results, if any.
   358  func (client AzureFirewallsClient) listNextResults(ctx context.Context, lastResults AzureFirewallListResult) (result AzureFirewallListResult, err error) {
   359  	req, err := lastResults.azureFirewallListResultPreparer(ctx)
   360  	if err != nil {
   361  		return result, autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "listNextResults", nil, "Failure preparing next results request")
   362  	}
   363  	if req == nil {
   364  		return
   365  	}
   366  	resp, err := client.ListSender(req)
   367  	if err != nil {
   368  		result.Response = autorest.Response{Response: resp}
   369  		return result, autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "listNextResults", resp, "Failure sending next results request")
   370  	}
   371  	result, err = client.ListResponder(resp)
   372  	if err != nil {
   373  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "listNextResults", resp, "Failure responding to next results request")
   374  	}
   375  	return
   376  }
   377  
   378  // ListComplete enumerates all values, automatically crossing page boundaries as required.
   379  func (client AzureFirewallsClient) ListComplete(ctx context.Context, resourceGroupName string) (result AzureFirewallListResultIterator, err error) {
   380  	if tracing.IsEnabled() {
   381  		ctx = tracing.StartSpan(ctx, fqdn+"/AzureFirewallsClient.List")
   382  		defer func() {
   383  			sc := -1
   384  			if result.Response().Response.Response != nil {
   385  				sc = result.page.Response().Response.Response.StatusCode
   386  			}
   387  			tracing.EndSpan(ctx, sc, err)
   388  		}()
   389  	}
   390  	result.page, err = client.List(ctx, resourceGroupName)
   391  	return
   392  }
   393  
   394  // ListAll gets all the Azure Firewalls in a subscription.
   395  func (client AzureFirewallsClient) ListAll(ctx context.Context) (result AzureFirewallListResultPage, err error) {
   396  	if tracing.IsEnabled() {
   397  		ctx = tracing.StartSpan(ctx, fqdn+"/AzureFirewallsClient.ListAll")
   398  		defer func() {
   399  			sc := -1
   400  			if result.aflr.Response.Response != nil {
   401  				sc = result.aflr.Response.Response.StatusCode
   402  			}
   403  			tracing.EndSpan(ctx, sc, err)
   404  		}()
   405  	}
   406  	result.fn = client.listAllNextResults
   407  	req, err := client.ListAllPreparer(ctx)
   408  	if err != nil {
   409  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "ListAll", nil, "Failure preparing request")
   410  		return
   411  	}
   412  
   413  	resp, err := client.ListAllSender(req)
   414  	if err != nil {
   415  		result.aflr.Response = autorest.Response{Response: resp}
   416  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "ListAll", resp, "Failure sending request")
   417  		return
   418  	}
   419  
   420  	result.aflr, err = client.ListAllResponder(resp)
   421  	if err != nil {
   422  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "ListAll", resp, "Failure responding to request")
   423  		return
   424  	}
   425  	if result.aflr.hasNextLink() && result.aflr.IsEmpty() {
   426  		err = result.NextWithContext(ctx)
   427  		return
   428  	}
   429  
   430  	return
   431  }
   432  
   433  // ListAllPreparer prepares the ListAll request.
   434  func (client AzureFirewallsClient) ListAllPreparer(ctx context.Context) (*http.Request, error) {
   435  	pathParameters := map[string]interface{}{
   436  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   437  	}
   438  
   439  	const APIVersion = "2020-04-01"
   440  	queryParameters := map[string]interface{}{
   441  		"api-version": APIVersion,
   442  	}
   443  
   444  	preparer := autorest.CreatePreparer(
   445  		autorest.AsGet(),
   446  		autorest.WithBaseURL(client.BaseURI),
   447  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/azureFirewalls", pathParameters),
   448  		autorest.WithQueryParameters(queryParameters))
   449  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   450  }
   451  
   452  // ListAllSender sends the ListAll request. The method will close the
   453  // http.Response Body if it receives an error.
   454  func (client AzureFirewallsClient) ListAllSender(req *http.Request) (*http.Response, error) {
   455  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   456  }
   457  
   458  // ListAllResponder handles the response to the ListAll request. The method always
   459  // closes the http.Response Body.
   460  func (client AzureFirewallsClient) ListAllResponder(resp *http.Response) (result AzureFirewallListResult, err error) {
   461  	err = autorest.Respond(
   462  		resp,
   463  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   464  		autorest.ByUnmarshallingJSON(&result),
   465  		autorest.ByClosing())
   466  	result.Response = autorest.Response{Response: resp}
   467  	return
   468  }
   469  
   470  // listAllNextResults retrieves the next set of results, if any.
   471  func (client AzureFirewallsClient) listAllNextResults(ctx context.Context, lastResults AzureFirewallListResult) (result AzureFirewallListResult, err error) {
   472  	req, err := lastResults.azureFirewallListResultPreparer(ctx)
   473  	if err != nil {
   474  		return result, autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "listAllNextResults", nil, "Failure preparing next results request")
   475  	}
   476  	if req == nil {
   477  		return
   478  	}
   479  	resp, err := client.ListAllSender(req)
   480  	if err != nil {
   481  		result.Response = autorest.Response{Response: resp}
   482  		return result, autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "listAllNextResults", resp, "Failure sending next results request")
   483  	}
   484  	result, err = client.ListAllResponder(resp)
   485  	if err != nil {
   486  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "listAllNextResults", resp, "Failure responding to next results request")
   487  	}
   488  	return
   489  }
   490  
   491  // ListAllComplete enumerates all values, automatically crossing page boundaries as required.
   492  func (client AzureFirewallsClient) ListAllComplete(ctx context.Context) (result AzureFirewallListResultIterator, err error) {
   493  	if tracing.IsEnabled() {
   494  		ctx = tracing.StartSpan(ctx, fqdn+"/AzureFirewallsClient.ListAll")
   495  		defer func() {
   496  			sc := -1
   497  			if result.Response().Response.Response != nil {
   498  				sc = result.page.Response().Response.Response.StatusCode
   499  			}
   500  			tracing.EndSpan(ctx, sc, err)
   501  		}()
   502  	}
   503  	result.page, err = client.ListAll(ctx)
   504  	return
   505  }
   506  
   507  // UpdateTags updates tags of an Azure Firewall resource.
   508  // Parameters:
   509  // resourceGroupName - the name of the resource group.
   510  // azureFirewallName - the name of the Azure Firewall.
   511  // parameters - parameters supplied to update azure firewall tags.
   512  func (client AzureFirewallsClient) UpdateTags(ctx context.Context, resourceGroupName string, azureFirewallName string, parameters TagsObject) (result AzureFirewallsUpdateTagsFuture, err error) {
   513  	if tracing.IsEnabled() {
   514  		ctx = tracing.StartSpan(ctx, fqdn+"/AzureFirewallsClient.UpdateTags")
   515  		defer func() {
   516  			sc := -1
   517  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   518  				sc = result.FutureAPI.Response().StatusCode
   519  			}
   520  			tracing.EndSpan(ctx, sc, err)
   521  		}()
   522  	}
   523  	req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, azureFirewallName, parameters)
   524  	if err != nil {
   525  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "UpdateTags", nil, "Failure preparing request")
   526  		return
   527  	}
   528  
   529  	result, err = client.UpdateTagsSender(req)
   530  	if err != nil {
   531  		err = autorest.NewErrorWithError(err, "network.AzureFirewallsClient", "UpdateTags", result.Response(), "Failure sending request")
   532  		return
   533  	}
   534  
   535  	return
   536  }
   537  
   538  // UpdateTagsPreparer prepares the UpdateTags request.
   539  func (client AzureFirewallsClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, azureFirewallName string, parameters TagsObject) (*http.Request, error) {
   540  	pathParameters := map[string]interface{}{
   541  		"azureFirewallName": autorest.Encode("path", azureFirewallName),
   542  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   543  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   544  	}
   545  
   546  	const APIVersion = "2020-04-01"
   547  	queryParameters := map[string]interface{}{
   548  		"api-version": APIVersion,
   549  	}
   550  
   551  	preparer := autorest.CreatePreparer(
   552  		autorest.AsContentType("application/json; charset=utf-8"),
   553  		autorest.AsPatch(),
   554  		autorest.WithBaseURL(client.BaseURI),
   555  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/azureFirewalls/{azureFirewallName}", pathParameters),
   556  		autorest.WithJSON(parameters),
   557  		autorest.WithQueryParameters(queryParameters))
   558  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   559  }
   560  
   561  // UpdateTagsSender sends the UpdateTags request. The method will close the
   562  // http.Response Body if it receives an error.
   563  func (client AzureFirewallsClient) UpdateTagsSender(req *http.Request) (future AzureFirewallsUpdateTagsFuture, err error) {
   564  	var resp *http.Response
   565  	future.FutureAPI = &azure.Future{}
   566  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   567  	if err != nil {
   568  		return
   569  	}
   570  	var azf azure.Future
   571  	azf, err = azure.NewFutureFromResponse(resp)
   572  	future.FutureAPI = &azf
   573  	future.Result = future.result
   574  	return
   575  }
   576  
   577  // UpdateTagsResponder handles the response to the UpdateTags request. The method always
   578  // closes the http.Response Body.
   579  func (client AzureFirewallsClient) UpdateTagsResponder(resp *http.Response) (result AzureFirewall, err error) {
   580  	err = autorest.Respond(
   581  		resp,
   582  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   583  		autorest.ByUnmarshallingJSON(&result),
   584  		autorest.ByClosing())
   585  	result.Response = autorest.Response{Response: resp}
   586  	return
   587  }
   588
View as plain text