1package network 2 3// Copyright (c) Microsoft and contributors. All rights reserved. 4// 5// Licensed under the Apache License, Version 2.0 (the "License"); 6// you may not use this file except in compliance with the License. 7// You may obtain a copy of the License at 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// 14// See the License for the specific language governing permissions and 15// limitations under the License. 16// 17// Code generated by Microsoft (R) AutoRest Code Generator. 18// Changes may cause incorrect behavior and will be lost if the code is regenerated. 19 20import ( 21 "context" 22 "github.com/Azure/go-autorest/autorest" 23 "github.com/Azure/go-autorest/autorest/azure" 24 "github.com/Azure/go-autorest/autorest/validation" 25 "github.com/Azure/go-autorest/tracing" 26 "net/http" 27) 28 29// VirtualNetworkGatewaysClient is the network Client 30type VirtualNetworkGatewaysClient struct { 31 BaseClient 32} 33 34// NewVirtualNetworkGatewaysClient creates an instance of the VirtualNetworkGatewaysClient client. 35func NewVirtualNetworkGatewaysClient(subscriptionID string) VirtualNetworkGatewaysClient { 36 return NewVirtualNetworkGatewaysClientWithBaseURI(DefaultBaseURI, subscriptionID) 37} 38 39// NewVirtualNetworkGatewaysClientWithBaseURI creates an instance of the VirtualNetworkGatewaysClient client using a 40// custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, 41// Azure stack). 42func NewVirtualNetworkGatewaysClientWithBaseURI(baseURI string, subscriptionID string) VirtualNetworkGatewaysClient { 43 return VirtualNetworkGatewaysClient{NewWithBaseURI(baseURI, subscriptionID)} 44} 45 46// CreateOrUpdate creates or updates a virtual network gateway in the specified resource group. 47// Parameters: 48// resourceGroupName - the name of the resource group. 49// virtualNetworkGatewayName - the name of the virtual network gateway. 50// parameters - parameters supplied to create or update virtual network gateway operation. 51func (client VirtualNetworkGatewaysClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VirtualNetworkGateway) (result VirtualNetworkGatewaysCreateOrUpdateFuture, err error) { 52 if tracing.IsEnabled() { 53 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.CreateOrUpdate") 54 defer func() { 55 sc := -1 56 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 57 sc = result.FutureAPI.Response().StatusCode 58 } 59 tracing.EndSpan(ctx, sc, err) 60 }() 61 } 62 if err := validation.Validate([]validation.Validation{ 63 {TargetValue: parameters, 64 Constraints: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayPropertiesFormat", Name: validation.Null, Rule: true, 65 Chain: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayPropertiesFormat.BgpSettings", Name: validation.Null, Rule: false, 66 Chain: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayPropertiesFormat.BgpSettings.Asn", Name: validation.Null, Rule: false, 67 Chain: []validation.Constraint{{Target: "parameters.VirtualNetworkGatewayPropertiesFormat.BgpSettings.Asn", Name: validation.InclusiveMaximum, Rule: int64(4294967295), Chain: nil}, 68 {Target: "parameters.VirtualNetworkGatewayPropertiesFormat.BgpSettings.Asn", Name: validation.InclusiveMinimum, Rule: int64(0), Chain: nil}, 69 }}, 70 }}, 71 }}}}}); err != nil { 72 return result, validation.NewError("network.VirtualNetworkGatewaysClient", "CreateOrUpdate", err.Error()) 73 } 74 75 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 76 if err != nil { 77 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "CreateOrUpdate", nil, "Failure preparing request") 78 return 79 } 80 81 result, err = client.CreateOrUpdateSender(req) 82 if err != nil { 83 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "CreateOrUpdate", nil, "Failure sending request") 84 return 85 } 86 87 return 88} 89 90// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 91func (client VirtualNetworkGatewaysClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VirtualNetworkGateway) (*http.Request, error) { 92 pathParameters := map[string]interface{}{ 93 "resourceGroupName": autorest.Encode("path", resourceGroupName), 94 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 95 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 96 } 97 98 const APIVersion = "2020-06-01" 99 queryParameters := map[string]interface{}{ 100 "api-version": APIVersion, 101 } 102 103 parameters.Etag = nil 104 preparer := autorest.CreatePreparer( 105 autorest.AsContentType("application/json; charset=utf-8"), 106 autorest.AsPut(), 107 autorest.WithBaseURL(client.BaseURI), 108 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters), 109 autorest.WithJSON(parameters), 110 autorest.WithQueryParameters(queryParameters)) 111 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 112} 113 114// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 115// http.Response Body if it receives an error. 116func (client VirtualNetworkGatewaysClient) CreateOrUpdateSender(req *http.Request) (future VirtualNetworkGatewaysCreateOrUpdateFuture, err error) { 117 var resp *http.Response 118 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 119 if err != nil { 120 return 121 } 122 var azf azure.Future 123 azf, err = azure.NewFutureFromResponse(resp) 124 future.FutureAPI = &azf 125 future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) { 126 var done bool 127 done, err = future.DoneWithContext(context.Background(), client) 128 if err != nil { 129 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") 130 return 131 } 132 if !done { 133 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysCreateOrUpdateFuture") 134 return 135 } 136 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 137 vng.Response.Response, err = future.GetResult(sender) 138 if vng.Response.Response == nil && err == nil { 139 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", nil, "received nil response and error") 140 } 141 if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent { 142 vng, err = client.CreateOrUpdateResponder(vng.Response.Response) 143 if err != nil { 144 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", vng.Response.Response, "Failure responding to request") 145 } 146 } 147 return 148 } 149 return 150} 151 152// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 153// closes the http.Response Body. 154func (client VirtualNetworkGatewaysClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualNetworkGateway, err error) { 155 err = autorest.Respond( 156 resp, 157 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 158 autorest.ByUnmarshallingJSON(&result), 159 autorest.ByClosing()) 160 result.Response = autorest.Response{Response: resp} 161 return 162} 163 164// Delete deletes the specified virtual network gateway. 165// Parameters: 166// resourceGroupName - the name of the resource group. 167// virtualNetworkGatewayName - the name of the virtual network gateway. 168func (client VirtualNetworkGatewaysClient) Delete(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysDeleteFuture, err error) { 169 if tracing.IsEnabled() { 170 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Delete") 171 defer func() { 172 sc := -1 173 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 174 sc = result.FutureAPI.Response().StatusCode 175 } 176 tracing.EndSpan(ctx, sc, err) 177 }() 178 } 179 req, err := client.DeletePreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 180 if err != nil { 181 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Delete", nil, "Failure preparing request") 182 return 183 } 184 185 result, err = client.DeleteSender(req) 186 if err != nil { 187 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Delete", nil, "Failure sending request") 188 return 189 } 190 191 return 192} 193 194// DeletePreparer prepares the Delete request. 195func (client VirtualNetworkGatewaysClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 196 pathParameters := map[string]interface{}{ 197 "resourceGroupName": autorest.Encode("path", resourceGroupName), 198 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 199 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 200 } 201 202 const APIVersion = "2020-06-01" 203 queryParameters := map[string]interface{}{ 204 "api-version": APIVersion, 205 } 206 207 preparer := autorest.CreatePreparer( 208 autorest.AsDelete(), 209 autorest.WithBaseURL(client.BaseURI), 210 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters), 211 autorest.WithQueryParameters(queryParameters)) 212 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 213} 214 215// DeleteSender sends the Delete request. The method will close the 216// http.Response Body if it receives an error. 217func (client VirtualNetworkGatewaysClient) DeleteSender(req *http.Request) (future VirtualNetworkGatewaysDeleteFuture, err error) { 218 var resp *http.Response 219 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 220 if err != nil { 221 return 222 } 223 var azf azure.Future 224 azf, err = azure.NewFutureFromResponse(resp) 225 future.FutureAPI = &azf 226 future.Result = func(client VirtualNetworkGatewaysClient) (ar autorest.Response, err error) { 227 var done bool 228 done, err = future.DoneWithContext(context.Background(), client) 229 if err != nil { 230 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysDeleteFuture", "Result", future.Response(), "Polling failure") 231 return 232 } 233 if !done { 234 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysDeleteFuture") 235 return 236 } 237 ar.Response = future.Response() 238 return 239 } 240 return 241} 242 243// DeleteResponder handles the response to the Delete request. The method always 244// closes the http.Response Body. 245func (client VirtualNetworkGatewaysClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 246 err = autorest.Respond( 247 resp, 248 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 249 autorest.ByClosing()) 250 result.Response = resp 251 return 252} 253 254// DisconnectVirtualNetworkGatewayVpnConnections disconnect vpn connections of virtual network gateway in the specified 255// resource group. 256// Parameters: 257// resourceGroupName - the name of the resource group. 258// virtualNetworkGatewayName - the name of the virtual network gateway. 259// request - the parameters are supplied to disconnect vpn connections. 260func (client VirtualNetworkGatewaysClient) DisconnectVirtualNetworkGatewayVpnConnections(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, request P2SVpnConnectionRequest) (result VirtualNetworkGatewaysDisconnectVirtualNetworkGatewayVpnConnectionsFuture, err error) { 261 if tracing.IsEnabled() { 262 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.DisconnectVirtualNetworkGatewayVpnConnections") 263 defer func() { 264 sc := -1 265 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 266 sc = result.FutureAPI.Response().StatusCode 267 } 268 tracing.EndSpan(ctx, sc, err) 269 }() 270 } 271 req, err := client.DisconnectVirtualNetworkGatewayVpnConnectionsPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, request) 272 if err != nil { 273 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "DisconnectVirtualNetworkGatewayVpnConnections", nil, "Failure preparing request") 274 return 275 } 276 277 result, err = client.DisconnectVirtualNetworkGatewayVpnConnectionsSender(req) 278 if err != nil { 279 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "DisconnectVirtualNetworkGatewayVpnConnections", nil, "Failure sending request") 280 return 281 } 282 283 return 284} 285 286// DisconnectVirtualNetworkGatewayVpnConnectionsPreparer prepares the DisconnectVirtualNetworkGatewayVpnConnections request. 287func (client VirtualNetworkGatewaysClient) DisconnectVirtualNetworkGatewayVpnConnectionsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, request P2SVpnConnectionRequest) (*http.Request, error) { 288 pathParameters := map[string]interface{}{ 289 "resourceGroupName": autorest.Encode("path", resourceGroupName), 290 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 291 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 292 } 293 294 const APIVersion = "2020-06-01" 295 queryParameters := map[string]interface{}{ 296 "api-version": APIVersion, 297 } 298 299 preparer := autorest.CreatePreparer( 300 autorest.AsContentType("application/json; charset=utf-8"), 301 autorest.AsPost(), 302 autorest.WithBaseURL(client.BaseURI), 303 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/disconnectVirtualNetworkGatewayVpnConnections", pathParameters), 304 autorest.WithJSON(request), 305 autorest.WithQueryParameters(queryParameters)) 306 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 307} 308 309// DisconnectVirtualNetworkGatewayVpnConnectionsSender sends the DisconnectVirtualNetworkGatewayVpnConnections request. The method will close the 310// http.Response Body if it receives an error. 311func (client VirtualNetworkGatewaysClient) DisconnectVirtualNetworkGatewayVpnConnectionsSender(req *http.Request) (future VirtualNetworkGatewaysDisconnectVirtualNetworkGatewayVpnConnectionsFuture, err error) { 312 var resp *http.Response 313 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 314 if err != nil { 315 return 316 } 317 var azf azure.Future 318 azf, err = azure.NewFutureFromResponse(resp) 319 future.FutureAPI = &azf 320 future.Result = func(client VirtualNetworkGatewaysClient) (ar autorest.Response, err error) { 321 var done bool 322 done, err = future.DoneWithContext(context.Background(), client) 323 if err != nil { 324 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysDisconnectVirtualNetworkGatewayVpnConnectionsFuture", "Result", future.Response(), "Polling failure") 325 return 326 } 327 if !done { 328 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysDisconnectVirtualNetworkGatewayVpnConnectionsFuture") 329 return 330 } 331 ar.Response = future.Response() 332 return 333 } 334 return 335} 336 337// DisconnectVirtualNetworkGatewayVpnConnectionsResponder handles the response to the DisconnectVirtualNetworkGatewayVpnConnections request. The method always 338// closes the http.Response Body. 339func (client VirtualNetworkGatewaysClient) DisconnectVirtualNetworkGatewayVpnConnectionsResponder(resp *http.Response) (result autorest.Response, err error) { 340 err = autorest.Respond( 341 resp, 342 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 343 autorest.ByClosing()) 344 result.Response = resp 345 return 346} 347 348// Generatevpnclientpackage generates VPN client package for P2S client of the virtual network gateway in the specified 349// resource group. 350// Parameters: 351// resourceGroupName - the name of the resource group. 352// virtualNetworkGatewayName - the name of the virtual network gateway. 353// parameters - parameters supplied to the generate virtual network gateway VPN client package operation. 354func (client VirtualNetworkGatewaysClient) Generatevpnclientpackage(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (result VirtualNetworkGatewaysGeneratevpnclientpackageFuture, err error) { 355 if tracing.IsEnabled() { 356 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Generatevpnclientpackage") 357 defer func() { 358 sc := -1 359 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 360 sc = result.FutureAPI.Response().StatusCode 361 } 362 tracing.EndSpan(ctx, sc, err) 363 }() 364 } 365 req, err := client.GeneratevpnclientpackagePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 366 if err != nil { 367 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Generatevpnclientpackage", nil, "Failure preparing request") 368 return 369 } 370 371 result, err = client.GeneratevpnclientpackageSender(req) 372 if err != nil { 373 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Generatevpnclientpackage", nil, "Failure sending request") 374 return 375 } 376 377 return 378} 379 380// GeneratevpnclientpackagePreparer prepares the Generatevpnclientpackage request. 381func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackagePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (*http.Request, error) { 382 pathParameters := map[string]interface{}{ 383 "resourceGroupName": autorest.Encode("path", resourceGroupName), 384 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 385 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 386 } 387 388 const APIVersion = "2020-06-01" 389 queryParameters := map[string]interface{}{ 390 "api-version": APIVersion, 391 } 392 393 preparer := autorest.CreatePreparer( 394 autorest.AsContentType("application/json; charset=utf-8"), 395 autorest.AsPost(), 396 autorest.WithBaseURL(client.BaseURI), 397 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnclientpackage", pathParameters), 398 autorest.WithJSON(parameters), 399 autorest.WithQueryParameters(queryParameters)) 400 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 401} 402 403// GeneratevpnclientpackageSender sends the Generatevpnclientpackage request. The method will close the 404// http.Response Body if it receives an error. 405func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackageSender(req *http.Request) (future VirtualNetworkGatewaysGeneratevpnclientpackageFuture, err error) { 406 var resp *http.Response 407 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 408 if err != nil { 409 return 410 } 411 var azf azure.Future 412 azf, err = azure.NewFutureFromResponse(resp) 413 future.FutureAPI = &azf 414 future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) { 415 var done bool 416 done, err = future.DoneWithContext(context.Background(), client) 417 if err != nil { 418 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", future.Response(), "Polling failure") 419 return 420 } 421 if !done { 422 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture") 423 return 424 } 425 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 426 s.Response.Response, err = future.GetResult(sender) 427 if s.Response.Response == nil && err == nil { 428 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", nil, "received nil response and error") 429 } 430 if err == nil && s.Response.Response.StatusCode != http.StatusNoContent { 431 s, err = client.GeneratevpnclientpackageResponder(s.Response.Response) 432 if err != nil { 433 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", s.Response.Response, "Failure responding to request") 434 } 435 } 436 return 437 } 438 return 439} 440 441// GeneratevpnclientpackageResponder handles the response to the Generatevpnclientpackage request. The method always 442// closes the http.Response Body. 443func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackageResponder(resp *http.Response) (result String, err error) { 444 err = autorest.Respond( 445 resp, 446 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 447 autorest.ByUnmarshallingJSON(&result), 448 autorest.ByClosing()) 449 result.Response = autorest.Response{Response: resp} 450 return 451} 452 453// GenerateVpnProfile generates VPN profile for P2S client of the virtual network gateway in the specified resource 454// group. Used for IKEV2 and radius based authentication. 455// Parameters: 456// resourceGroupName - the name of the resource group. 457// virtualNetworkGatewayName - the name of the virtual network gateway. 458// parameters - parameters supplied to the generate virtual network gateway VPN client package operation. 459func (client VirtualNetworkGatewaysClient) GenerateVpnProfile(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (result VirtualNetworkGatewaysGenerateVpnProfileFuture, err error) { 460 if tracing.IsEnabled() { 461 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GenerateVpnProfile") 462 defer func() { 463 sc := -1 464 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 465 sc = result.FutureAPI.Response().StatusCode 466 } 467 tracing.EndSpan(ctx, sc, err) 468 }() 469 } 470 req, err := client.GenerateVpnProfilePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 471 if err != nil { 472 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GenerateVpnProfile", nil, "Failure preparing request") 473 return 474 } 475 476 result, err = client.GenerateVpnProfileSender(req) 477 if err != nil { 478 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GenerateVpnProfile", nil, "Failure sending request") 479 return 480 } 481 482 return 483} 484 485// GenerateVpnProfilePreparer prepares the GenerateVpnProfile request. 486func (client VirtualNetworkGatewaysClient) GenerateVpnProfilePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (*http.Request, error) { 487 pathParameters := map[string]interface{}{ 488 "resourceGroupName": autorest.Encode("path", resourceGroupName), 489 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 490 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 491 } 492 493 const APIVersion = "2020-06-01" 494 queryParameters := map[string]interface{}{ 495 "api-version": APIVersion, 496 } 497 498 preparer := autorest.CreatePreparer( 499 autorest.AsContentType("application/json; charset=utf-8"), 500 autorest.AsPost(), 501 autorest.WithBaseURL(client.BaseURI), 502 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnprofile", pathParameters), 503 autorest.WithJSON(parameters), 504 autorest.WithQueryParameters(queryParameters)) 505 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 506} 507 508// GenerateVpnProfileSender sends the GenerateVpnProfile request. The method will close the 509// http.Response Body if it receives an error. 510func (client VirtualNetworkGatewaysClient) GenerateVpnProfileSender(req *http.Request) (future VirtualNetworkGatewaysGenerateVpnProfileFuture, err error) { 511 var resp *http.Response 512 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 513 if err != nil { 514 return 515 } 516 var azf azure.Future 517 azf, err = azure.NewFutureFromResponse(resp) 518 future.FutureAPI = &azf 519 future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) { 520 var done bool 521 done, err = future.DoneWithContext(context.Background(), client) 522 if err != nil { 523 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", future.Response(), "Polling failure") 524 return 525 } 526 if !done { 527 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGenerateVpnProfileFuture") 528 return 529 } 530 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 531 s.Response.Response, err = future.GetResult(sender) 532 if s.Response.Response == nil && err == nil { 533 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", nil, "received nil response and error") 534 } 535 if err == nil && s.Response.Response.StatusCode != http.StatusNoContent { 536 s, err = client.GenerateVpnProfileResponder(s.Response.Response) 537 if err != nil { 538 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", s.Response.Response, "Failure responding to request") 539 } 540 } 541 return 542 } 543 return 544} 545 546// GenerateVpnProfileResponder handles the response to the GenerateVpnProfile request. The method always 547// closes the http.Response Body. 548func (client VirtualNetworkGatewaysClient) GenerateVpnProfileResponder(resp *http.Response) (result String, err error) { 549 err = autorest.Respond( 550 resp, 551 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 552 autorest.ByUnmarshallingJSON(&result), 553 autorest.ByClosing()) 554 result.Response = autorest.Response{Response: resp} 555 return 556} 557 558// Get gets the specified virtual network gateway by resource group. 559// Parameters: 560// resourceGroupName - the name of the resource group. 561// virtualNetworkGatewayName - the name of the virtual network gateway. 562func (client VirtualNetworkGatewaysClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGateway, err error) { 563 if tracing.IsEnabled() { 564 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Get") 565 defer func() { 566 sc := -1 567 if result.Response.Response != nil { 568 sc = result.Response.Response.StatusCode 569 } 570 tracing.EndSpan(ctx, sc, err) 571 }() 572 } 573 req, err := client.GetPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 574 if err != nil { 575 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", nil, "Failure preparing request") 576 return 577 } 578 579 resp, err := client.GetSender(req) 580 if err != nil { 581 result.Response = autorest.Response{Response: resp} 582 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", resp, "Failure sending request") 583 return 584 } 585 586 result, err = client.GetResponder(resp) 587 if err != nil { 588 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", resp, "Failure responding to request") 589 return 590 } 591 592 return 593} 594 595// GetPreparer prepares the Get request. 596func (client VirtualNetworkGatewaysClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 597 pathParameters := map[string]interface{}{ 598 "resourceGroupName": autorest.Encode("path", resourceGroupName), 599 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 600 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 601 } 602 603 const APIVersion = "2020-06-01" 604 queryParameters := map[string]interface{}{ 605 "api-version": APIVersion, 606 } 607 608 preparer := autorest.CreatePreparer( 609 autorest.AsGet(), 610 autorest.WithBaseURL(client.BaseURI), 611 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters), 612 autorest.WithQueryParameters(queryParameters)) 613 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 614} 615 616// GetSender sends the Get request. The method will close the 617// http.Response Body if it receives an error. 618func (client VirtualNetworkGatewaysClient) GetSender(req *http.Request) (*http.Response, error) { 619 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 620} 621 622// GetResponder handles the response to the Get request. The method always 623// closes the http.Response Body. 624func (client VirtualNetworkGatewaysClient) GetResponder(resp *http.Response) (result VirtualNetworkGateway, err error) { 625 err = autorest.Respond( 626 resp, 627 azure.WithErrorUnlessStatusCode(http.StatusOK), 628 autorest.ByUnmarshallingJSON(&result), 629 autorest.ByClosing()) 630 result.Response = autorest.Response{Response: resp} 631 return 632} 633 634// GetAdvertisedRoutes this operation retrieves a list of routes the virtual network gateway is advertising to the 635// specified peer. 636// Parameters: 637// resourceGroupName - the name of the resource group. 638// virtualNetworkGatewayName - the name of the virtual network gateway. 639// peer - the IP address of the peer. 640func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (result VirtualNetworkGatewaysGetAdvertisedRoutesFuture, err error) { 641 if tracing.IsEnabled() { 642 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetAdvertisedRoutes") 643 defer func() { 644 sc := -1 645 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 646 sc = result.FutureAPI.Response().StatusCode 647 } 648 tracing.EndSpan(ctx, sc, err) 649 }() 650 } 651 req, err := client.GetAdvertisedRoutesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, peer) 652 if err != nil { 653 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetAdvertisedRoutes", nil, "Failure preparing request") 654 return 655 } 656 657 result, err = client.GetAdvertisedRoutesSender(req) 658 if err != nil { 659 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetAdvertisedRoutes", nil, "Failure sending request") 660 return 661 } 662 663 return 664} 665 666// GetAdvertisedRoutesPreparer prepares the GetAdvertisedRoutes request. 667func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (*http.Request, error) { 668 pathParameters := map[string]interface{}{ 669 "resourceGroupName": autorest.Encode("path", resourceGroupName), 670 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 671 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 672 } 673 674 const APIVersion = "2020-06-01" 675 queryParameters := map[string]interface{}{ 676 "api-version": APIVersion, 677 "peer": autorest.Encode("query", peer), 678 } 679 680 preparer := autorest.CreatePreparer( 681 autorest.AsPost(), 682 autorest.WithBaseURL(client.BaseURI), 683 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getAdvertisedRoutes", pathParameters), 684 autorest.WithQueryParameters(queryParameters)) 685 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 686} 687 688// GetAdvertisedRoutesSender sends the GetAdvertisedRoutes request. The method will close the 689// http.Response Body if it receives an error. 690func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesSender(req *http.Request) (future VirtualNetworkGatewaysGetAdvertisedRoutesFuture, err error) { 691 var resp *http.Response 692 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 693 if err != nil { 694 return 695 } 696 var azf azure.Future 697 azf, err = azure.NewFutureFromResponse(resp) 698 future.FutureAPI = &azf 699 future.Result = func(client VirtualNetworkGatewaysClient) (grlr GatewayRouteListResult, err error) { 700 var done bool 701 done, err = future.DoneWithContext(context.Background(), client) 702 if err != nil { 703 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", future.Response(), "Polling failure") 704 return 705 } 706 if !done { 707 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture") 708 return 709 } 710 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 711 grlr.Response.Response, err = future.GetResult(sender) 712 if grlr.Response.Response == nil && err == nil { 713 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", nil, "received nil response and error") 714 } 715 if err == nil && grlr.Response.Response.StatusCode != http.StatusNoContent { 716 grlr, err = client.GetAdvertisedRoutesResponder(grlr.Response.Response) 717 if err != nil { 718 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", grlr.Response.Response, "Failure responding to request") 719 } 720 } 721 return 722 } 723 return 724} 725 726// GetAdvertisedRoutesResponder handles the response to the GetAdvertisedRoutes request. The method always 727// closes the http.Response Body. 728func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesResponder(resp *http.Response) (result GatewayRouteListResult, err error) { 729 err = autorest.Respond( 730 resp, 731 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 732 autorest.ByUnmarshallingJSON(&result), 733 autorest.ByClosing()) 734 result.Response = autorest.Response{Response: resp} 735 return 736} 737 738// GetBgpPeerStatus the GetBgpPeerStatus operation retrieves the status of all BGP peers. 739// Parameters: 740// resourceGroupName - the name of the resource group. 741// virtualNetworkGatewayName - the name of the virtual network gateway. 742// peer - the IP address of the peer to retrieve the status of. 743func (client VirtualNetworkGatewaysClient) GetBgpPeerStatus(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (result VirtualNetworkGatewaysGetBgpPeerStatusFuture, err error) { 744 if tracing.IsEnabled() { 745 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetBgpPeerStatus") 746 defer func() { 747 sc := -1 748 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 749 sc = result.FutureAPI.Response().StatusCode 750 } 751 tracing.EndSpan(ctx, sc, err) 752 }() 753 } 754 req, err := client.GetBgpPeerStatusPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, peer) 755 if err != nil { 756 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetBgpPeerStatus", nil, "Failure preparing request") 757 return 758 } 759 760 result, err = client.GetBgpPeerStatusSender(req) 761 if err != nil { 762 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetBgpPeerStatus", nil, "Failure sending request") 763 return 764 } 765 766 return 767} 768 769// GetBgpPeerStatusPreparer prepares the GetBgpPeerStatus request. 770func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (*http.Request, error) { 771 pathParameters := map[string]interface{}{ 772 "resourceGroupName": autorest.Encode("path", resourceGroupName), 773 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 774 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 775 } 776 777 const APIVersion = "2020-06-01" 778 queryParameters := map[string]interface{}{ 779 "api-version": APIVersion, 780 } 781 if len(peer) > 0 { 782 queryParameters["peer"] = autorest.Encode("query", peer) 783 } 784 785 preparer := autorest.CreatePreparer( 786 autorest.AsPost(), 787 autorest.WithBaseURL(client.BaseURI), 788 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getBgpPeerStatus", pathParameters), 789 autorest.WithQueryParameters(queryParameters)) 790 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 791} 792 793// GetBgpPeerStatusSender sends the GetBgpPeerStatus request. The method will close the 794// http.Response Body if it receives an error. 795func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusSender(req *http.Request) (future VirtualNetworkGatewaysGetBgpPeerStatusFuture, err error) { 796 var resp *http.Response 797 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 798 if err != nil { 799 return 800 } 801 var azf azure.Future 802 azf, err = azure.NewFutureFromResponse(resp) 803 future.FutureAPI = &azf 804 future.Result = func(client VirtualNetworkGatewaysClient) (bpslr BgpPeerStatusListResult, err error) { 805 var done bool 806 done, err = future.DoneWithContext(context.Background(), client) 807 if err != nil { 808 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", future.Response(), "Polling failure") 809 return 810 } 811 if !done { 812 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetBgpPeerStatusFuture") 813 return 814 } 815 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 816 bpslr.Response.Response, err = future.GetResult(sender) 817 if bpslr.Response.Response == nil && err == nil { 818 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", nil, "received nil response and error") 819 } 820 if err == nil && bpslr.Response.Response.StatusCode != http.StatusNoContent { 821 bpslr, err = client.GetBgpPeerStatusResponder(bpslr.Response.Response) 822 if err != nil { 823 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", bpslr.Response.Response, "Failure responding to request") 824 } 825 } 826 return 827 } 828 return 829} 830 831// GetBgpPeerStatusResponder handles the response to the GetBgpPeerStatus request. The method always 832// closes the http.Response Body. 833func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusResponder(resp *http.Response) (result BgpPeerStatusListResult, err error) { 834 err = autorest.Respond( 835 resp, 836 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 837 autorest.ByUnmarshallingJSON(&result), 838 autorest.ByClosing()) 839 result.Response = autorest.Response{Response: resp} 840 return 841} 842 843// GetLearnedRoutes this operation retrieves a list of routes the virtual network gateway has learned, including routes 844// learned from BGP peers. 845// Parameters: 846// resourceGroupName - the name of the resource group. 847// virtualNetworkGatewayName - the name of the virtual network gateway. 848func (client VirtualNetworkGatewaysClient) GetLearnedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetLearnedRoutesFuture, err error) { 849 if tracing.IsEnabled() { 850 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetLearnedRoutes") 851 defer func() { 852 sc := -1 853 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 854 sc = result.FutureAPI.Response().StatusCode 855 } 856 tracing.EndSpan(ctx, sc, err) 857 }() 858 } 859 req, err := client.GetLearnedRoutesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 860 if err != nil { 861 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetLearnedRoutes", nil, "Failure preparing request") 862 return 863 } 864 865 result, err = client.GetLearnedRoutesSender(req) 866 if err != nil { 867 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetLearnedRoutes", nil, "Failure sending request") 868 return 869 } 870 871 return 872} 873 874// GetLearnedRoutesPreparer prepares the GetLearnedRoutes request. 875func (client VirtualNetworkGatewaysClient) GetLearnedRoutesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 876 pathParameters := map[string]interface{}{ 877 "resourceGroupName": autorest.Encode("path", resourceGroupName), 878 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 879 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 880 } 881 882 const APIVersion = "2020-06-01" 883 queryParameters := map[string]interface{}{ 884 "api-version": APIVersion, 885 } 886 887 preparer := autorest.CreatePreparer( 888 autorest.AsPost(), 889 autorest.WithBaseURL(client.BaseURI), 890 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getLearnedRoutes", pathParameters), 891 autorest.WithQueryParameters(queryParameters)) 892 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 893} 894 895// GetLearnedRoutesSender sends the GetLearnedRoutes request. The method will close the 896// http.Response Body if it receives an error. 897func (client VirtualNetworkGatewaysClient) GetLearnedRoutesSender(req *http.Request) (future VirtualNetworkGatewaysGetLearnedRoutesFuture, err error) { 898 var resp *http.Response 899 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 900 if err != nil { 901 return 902 } 903 var azf azure.Future 904 azf, err = azure.NewFutureFromResponse(resp) 905 future.FutureAPI = &azf 906 future.Result = func(client VirtualNetworkGatewaysClient) (grlr GatewayRouteListResult, err error) { 907 var done bool 908 done, err = future.DoneWithContext(context.Background(), client) 909 if err != nil { 910 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", future.Response(), "Polling failure") 911 return 912 } 913 if !done { 914 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetLearnedRoutesFuture") 915 return 916 } 917 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 918 grlr.Response.Response, err = future.GetResult(sender) 919 if grlr.Response.Response == nil && err == nil { 920 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", nil, "received nil response and error") 921 } 922 if err == nil && grlr.Response.Response.StatusCode != http.StatusNoContent { 923 grlr, err = client.GetLearnedRoutesResponder(grlr.Response.Response) 924 if err != nil { 925 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", grlr.Response.Response, "Failure responding to request") 926 } 927 } 928 return 929 } 930 return 931} 932 933// GetLearnedRoutesResponder handles the response to the GetLearnedRoutes request. The method always 934// closes the http.Response Body. 935func (client VirtualNetworkGatewaysClient) GetLearnedRoutesResponder(resp *http.Response) (result GatewayRouteListResult, err error) { 936 err = autorest.Respond( 937 resp, 938 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 939 autorest.ByUnmarshallingJSON(&result), 940 autorest.ByClosing()) 941 result.Response = autorest.Response{Response: resp} 942 return 943} 944 945// GetVpnclientConnectionHealth get VPN client connection health detail per P2S client connection of the virtual 946// network gateway in the specified resource group. 947// Parameters: 948// resourceGroupName - the name of the resource group. 949// virtualNetworkGatewayName - the name of the virtual network gateway. 950func (client VirtualNetworkGatewaysClient) GetVpnclientConnectionHealth(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture, err error) { 951 if tracing.IsEnabled() { 952 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetVpnclientConnectionHealth") 953 defer func() { 954 sc := -1 955 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 956 sc = result.FutureAPI.Response().StatusCode 957 } 958 tracing.EndSpan(ctx, sc, err) 959 }() 960 } 961 req, err := client.GetVpnclientConnectionHealthPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 962 if err != nil { 963 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnclientConnectionHealth", nil, "Failure preparing request") 964 return 965 } 966 967 result, err = client.GetVpnclientConnectionHealthSender(req) 968 if err != nil { 969 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnclientConnectionHealth", nil, "Failure sending request") 970 return 971 } 972 973 return 974} 975 976// GetVpnclientConnectionHealthPreparer prepares the GetVpnclientConnectionHealth request. 977func (client VirtualNetworkGatewaysClient) GetVpnclientConnectionHealthPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 978 pathParameters := map[string]interface{}{ 979 "resourceGroupName": autorest.Encode("path", resourceGroupName), 980 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 981 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 982 } 983 984 const APIVersion = "2020-06-01" 985 queryParameters := map[string]interface{}{ 986 "api-version": APIVersion, 987 } 988 989 preparer := autorest.CreatePreparer( 990 autorest.AsPost(), 991 autorest.WithBaseURL(client.BaseURI), 992 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getVpnClientConnectionHealth", pathParameters), 993 autorest.WithQueryParameters(queryParameters)) 994 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 995} 996 997// GetVpnclientConnectionHealthSender sends the GetVpnclientConnectionHealth request. The method will close the 998// http.Response Body if it receives an error. 999func (client VirtualNetworkGatewaysClient) GetVpnclientConnectionHealthSender(req *http.Request) (future VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture, err error) { 1000 var resp *http.Response 1001 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1002 if err != nil { 1003 return 1004 } 1005 var azf azure.Future 1006 azf, err = azure.NewFutureFromResponse(resp) 1007 future.FutureAPI = &azf 1008 future.Result = func(client VirtualNetworkGatewaysClient) (vcchdlr VpnClientConnectionHealthDetailListResult, err error) { 1009 var done bool 1010 done, err = future.DoneWithContext(context.Background(), client) 1011 if err != nil { 1012 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture", "Result", future.Response(), "Polling failure") 1013 return 1014 } 1015 if !done { 1016 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture") 1017 return 1018 } 1019 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1020 vcchdlr.Response.Response, err = future.GetResult(sender) 1021 if vcchdlr.Response.Response == nil && err == nil { 1022 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture", "Result", nil, "received nil response and error") 1023 } 1024 if err == nil && vcchdlr.Response.Response.StatusCode != http.StatusNoContent { 1025 vcchdlr, err = client.GetVpnclientConnectionHealthResponder(vcchdlr.Response.Response) 1026 if err != nil { 1027 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture", "Result", vcchdlr.Response.Response, "Failure responding to request") 1028 } 1029 } 1030 return 1031 } 1032 return 1033} 1034 1035// GetVpnclientConnectionHealthResponder handles the response to the GetVpnclientConnectionHealth request. The method always 1036// closes the http.Response Body. 1037func (client VirtualNetworkGatewaysClient) GetVpnclientConnectionHealthResponder(resp *http.Response) (result VpnClientConnectionHealthDetailListResult, err error) { 1038 err = autorest.Respond( 1039 resp, 1040 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1041 autorest.ByUnmarshallingJSON(&result), 1042 autorest.ByClosing()) 1043 result.Response = autorest.Response{Response: resp} 1044 return 1045} 1046 1047// GetVpnclientIpsecParameters the Get VpnclientIpsecParameters operation retrieves information about the vpnclient 1048// ipsec policy for P2S client of virtual network gateway in the specified resource group through Network resource 1049// provider. 1050// Parameters: 1051// resourceGroupName - the name of the resource group. 1052// virtualNetworkGatewayName - the virtual network gateway name. 1053func (client VirtualNetworkGatewaysClient) GetVpnclientIpsecParameters(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture, err error) { 1054 if tracing.IsEnabled() { 1055 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetVpnclientIpsecParameters") 1056 defer func() { 1057 sc := -1 1058 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1059 sc = result.FutureAPI.Response().StatusCode 1060 } 1061 tracing.EndSpan(ctx, sc, err) 1062 }() 1063 } 1064 req, err := client.GetVpnclientIpsecParametersPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 1065 if err != nil { 1066 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnclientIpsecParameters", nil, "Failure preparing request") 1067 return 1068 } 1069 1070 result, err = client.GetVpnclientIpsecParametersSender(req) 1071 if err != nil { 1072 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnclientIpsecParameters", nil, "Failure sending request") 1073 return 1074 } 1075 1076 return 1077} 1078 1079// GetVpnclientIpsecParametersPreparer prepares the GetVpnclientIpsecParameters request. 1080func (client VirtualNetworkGatewaysClient) GetVpnclientIpsecParametersPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 1081 pathParameters := map[string]interface{}{ 1082 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1083 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1084 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1085 } 1086 1087 const APIVersion = "2020-06-01" 1088 queryParameters := map[string]interface{}{ 1089 "api-version": APIVersion, 1090 } 1091 1092 preparer := autorest.CreatePreparer( 1093 autorest.AsPost(), 1094 autorest.WithBaseURL(client.BaseURI), 1095 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getvpnclientipsecparameters", pathParameters), 1096 autorest.WithQueryParameters(queryParameters)) 1097 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1098} 1099 1100// GetVpnclientIpsecParametersSender sends the GetVpnclientIpsecParameters request. The method will close the 1101// http.Response Body if it receives an error. 1102func (client VirtualNetworkGatewaysClient) GetVpnclientIpsecParametersSender(req *http.Request) (future VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture, err error) { 1103 var resp *http.Response 1104 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1105 if err != nil { 1106 return 1107 } 1108 var azf azure.Future 1109 azf, err = azure.NewFutureFromResponse(resp) 1110 future.FutureAPI = &azf 1111 future.Result = func(client VirtualNetworkGatewaysClient) (vcipp VpnClientIPsecParameters, err error) { 1112 var done bool 1113 done, err = future.DoneWithContext(context.Background(), client) 1114 if err != nil { 1115 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture", "Result", future.Response(), "Polling failure") 1116 return 1117 } 1118 if !done { 1119 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture") 1120 return 1121 } 1122 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1123 vcipp.Response.Response, err = future.GetResult(sender) 1124 if vcipp.Response.Response == nil && err == nil { 1125 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture", "Result", nil, "received nil response and error") 1126 } 1127 if err == nil && vcipp.Response.Response.StatusCode != http.StatusNoContent { 1128 vcipp, err = client.GetVpnclientIpsecParametersResponder(vcipp.Response.Response) 1129 if err != nil { 1130 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture", "Result", vcipp.Response.Response, "Failure responding to request") 1131 } 1132 } 1133 return 1134 } 1135 return 1136} 1137 1138// GetVpnclientIpsecParametersResponder handles the response to the GetVpnclientIpsecParameters request. The method always 1139// closes the http.Response Body. 1140func (client VirtualNetworkGatewaysClient) GetVpnclientIpsecParametersResponder(resp *http.Response) (result VpnClientIPsecParameters, err error) { 1141 err = autorest.Respond( 1142 resp, 1143 azure.WithErrorUnlessStatusCode(http.StatusOK), 1144 autorest.ByUnmarshallingJSON(&result), 1145 autorest.ByClosing()) 1146 result.Response = autorest.Response{Response: resp} 1147 return 1148} 1149 1150// GetVpnProfilePackageURL gets pre-generated VPN profile for P2S client of the virtual network gateway in the 1151// specified resource group. The profile needs to be generated first using generateVpnProfile. 1152// Parameters: 1153// resourceGroupName - the name of the resource group. 1154// virtualNetworkGatewayName - the name of the virtual network gateway. 1155func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURL(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetVpnProfilePackageURLFuture, err error) { 1156 if tracing.IsEnabled() { 1157 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetVpnProfilePackageURL") 1158 defer func() { 1159 sc := -1 1160 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1161 sc = result.FutureAPI.Response().StatusCode 1162 } 1163 tracing.EndSpan(ctx, sc, err) 1164 }() 1165 } 1166 req, err := client.GetVpnProfilePackageURLPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 1167 if err != nil { 1168 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnProfilePackageURL", nil, "Failure preparing request") 1169 return 1170 } 1171 1172 result, err = client.GetVpnProfilePackageURLSender(req) 1173 if err != nil { 1174 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnProfilePackageURL", nil, "Failure sending request") 1175 return 1176 } 1177 1178 return 1179} 1180 1181// GetVpnProfilePackageURLPreparer prepares the GetVpnProfilePackageURL request. 1182func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 1183 pathParameters := map[string]interface{}{ 1184 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1185 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1186 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1187 } 1188 1189 const APIVersion = "2020-06-01" 1190 queryParameters := map[string]interface{}{ 1191 "api-version": APIVersion, 1192 } 1193 1194 preparer := autorest.CreatePreparer( 1195 autorest.AsPost(), 1196 autorest.WithBaseURL(client.BaseURI), 1197 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getvpnprofilepackageurl", pathParameters), 1198 autorest.WithQueryParameters(queryParameters)) 1199 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1200} 1201 1202// GetVpnProfilePackageURLSender sends the GetVpnProfilePackageURL request. The method will close the 1203// http.Response Body if it receives an error. 1204func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLSender(req *http.Request) (future VirtualNetworkGatewaysGetVpnProfilePackageURLFuture, err error) { 1205 var resp *http.Response 1206 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1207 if err != nil { 1208 return 1209 } 1210 var azf azure.Future 1211 azf, err = azure.NewFutureFromResponse(resp) 1212 future.FutureAPI = &azf 1213 future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) { 1214 var done bool 1215 done, err = future.DoneWithContext(context.Background(), client) 1216 if err != nil { 1217 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", future.Response(), "Polling failure") 1218 return 1219 } 1220 if !done { 1221 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture") 1222 return 1223 } 1224 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1225 s.Response.Response, err = future.GetResult(sender) 1226 if s.Response.Response == nil && err == nil { 1227 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", nil, "received nil response and error") 1228 } 1229 if err == nil && s.Response.Response.StatusCode != http.StatusNoContent { 1230 s, err = client.GetVpnProfilePackageURLResponder(s.Response.Response) 1231 if err != nil { 1232 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", s.Response.Response, "Failure responding to request") 1233 } 1234 } 1235 return 1236 } 1237 return 1238} 1239 1240// GetVpnProfilePackageURLResponder handles the response to the GetVpnProfilePackageURL request. The method always 1241// closes the http.Response Body. 1242func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLResponder(resp *http.Response) (result String, err error) { 1243 err = autorest.Respond( 1244 resp, 1245 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1246 autorest.ByUnmarshallingJSON(&result), 1247 autorest.ByClosing()) 1248 result.Response = autorest.Response{Response: resp} 1249 return 1250} 1251 1252// List gets all virtual network gateways by resource group. 1253// Parameters: 1254// resourceGroupName - the name of the resource group. 1255func (client VirtualNetworkGatewaysClient) List(ctx context.Context, resourceGroupName string) (result VirtualNetworkGatewayListResultPage, err error) { 1256 if tracing.IsEnabled() { 1257 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.List") 1258 defer func() { 1259 sc := -1 1260 if result.vnglr.Response.Response != nil { 1261 sc = result.vnglr.Response.Response.StatusCode 1262 } 1263 tracing.EndSpan(ctx, sc, err) 1264 }() 1265 } 1266 result.fn = client.listNextResults 1267 req, err := client.ListPreparer(ctx, resourceGroupName) 1268 if err != nil { 1269 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", nil, "Failure preparing request") 1270 return 1271 } 1272 1273 resp, err := client.ListSender(req) 1274 if err != nil { 1275 result.vnglr.Response = autorest.Response{Response: resp} 1276 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", resp, "Failure sending request") 1277 return 1278 } 1279 1280 result.vnglr, err = client.ListResponder(resp) 1281 if err != nil { 1282 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", resp, "Failure responding to request") 1283 return 1284 } 1285 if result.vnglr.hasNextLink() && result.vnglr.IsEmpty() { 1286 err = result.NextWithContext(ctx) 1287 return 1288 } 1289 1290 return 1291} 1292 1293// ListPreparer prepares the List request. 1294func (client VirtualNetworkGatewaysClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 1295 pathParameters := map[string]interface{}{ 1296 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1297 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1298 } 1299 1300 const APIVersion = "2020-06-01" 1301 queryParameters := map[string]interface{}{ 1302 "api-version": APIVersion, 1303 } 1304 1305 preparer := autorest.CreatePreparer( 1306 autorest.AsGet(), 1307 autorest.WithBaseURL(client.BaseURI), 1308 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways", pathParameters), 1309 autorest.WithQueryParameters(queryParameters)) 1310 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1311} 1312 1313// ListSender sends the List request. The method will close the 1314// http.Response Body if it receives an error. 1315func (client VirtualNetworkGatewaysClient) ListSender(req *http.Request) (*http.Response, error) { 1316 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1317} 1318 1319// ListResponder handles the response to the List request. The method always 1320// closes the http.Response Body. 1321func (client VirtualNetworkGatewaysClient) ListResponder(resp *http.Response) (result VirtualNetworkGatewayListResult, err error) { 1322 err = autorest.Respond( 1323 resp, 1324 azure.WithErrorUnlessStatusCode(http.StatusOK), 1325 autorest.ByUnmarshallingJSON(&result), 1326 autorest.ByClosing()) 1327 result.Response = autorest.Response{Response: resp} 1328 return 1329} 1330 1331// listNextResults retrieves the next set of results, if any. 1332func (client VirtualNetworkGatewaysClient) listNextResults(ctx context.Context, lastResults VirtualNetworkGatewayListResult) (result VirtualNetworkGatewayListResult, err error) { 1333 req, err := lastResults.virtualNetworkGatewayListResultPreparer(ctx) 1334 if err != nil { 1335 return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", nil, "Failure preparing next results request") 1336 } 1337 if req == nil { 1338 return 1339 } 1340 resp, err := client.ListSender(req) 1341 if err != nil { 1342 result.Response = autorest.Response{Response: resp} 1343 return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", resp, "Failure sending next results request") 1344 } 1345 result, err = client.ListResponder(resp) 1346 if err != nil { 1347 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", resp, "Failure responding to next results request") 1348 } 1349 return 1350} 1351 1352// ListComplete enumerates all values, automatically crossing page boundaries as required. 1353func (client VirtualNetworkGatewaysClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualNetworkGatewayListResultIterator, err error) { 1354 if tracing.IsEnabled() { 1355 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.List") 1356 defer func() { 1357 sc := -1 1358 if result.Response().Response.Response != nil { 1359 sc = result.page.Response().Response.Response.StatusCode 1360 } 1361 tracing.EndSpan(ctx, sc, err) 1362 }() 1363 } 1364 result.page, err = client.List(ctx, resourceGroupName) 1365 return 1366} 1367 1368// ListConnections gets all the connections in a virtual network gateway. 1369// Parameters: 1370// resourceGroupName - the name of the resource group. 1371// virtualNetworkGatewayName - the name of the virtual network gateway. 1372func (client VirtualNetworkGatewaysClient) ListConnections(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewayListConnectionsResultPage, err error) { 1373 if tracing.IsEnabled() { 1374 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.ListConnections") 1375 defer func() { 1376 sc := -1 1377 if result.vnglcr.Response.Response != nil { 1378 sc = result.vnglcr.Response.Response.StatusCode 1379 } 1380 tracing.EndSpan(ctx, sc, err) 1381 }() 1382 } 1383 result.fn = client.listConnectionsNextResults 1384 req, err := client.ListConnectionsPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 1385 if err != nil { 1386 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", nil, "Failure preparing request") 1387 return 1388 } 1389 1390 resp, err := client.ListConnectionsSender(req) 1391 if err != nil { 1392 result.vnglcr.Response = autorest.Response{Response: resp} 1393 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", resp, "Failure sending request") 1394 return 1395 } 1396 1397 result.vnglcr, err = client.ListConnectionsResponder(resp) 1398 if err != nil { 1399 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", resp, "Failure responding to request") 1400 return 1401 } 1402 if result.vnglcr.hasNextLink() && result.vnglcr.IsEmpty() { 1403 err = result.NextWithContext(ctx) 1404 return 1405 } 1406 1407 return 1408} 1409 1410// ListConnectionsPreparer prepares the ListConnections request. 1411func (client VirtualNetworkGatewaysClient) ListConnectionsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 1412 pathParameters := map[string]interface{}{ 1413 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1414 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1415 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1416 } 1417 1418 const APIVersion = "2020-06-01" 1419 queryParameters := map[string]interface{}{ 1420 "api-version": APIVersion, 1421 } 1422 1423 preparer := autorest.CreatePreparer( 1424 autorest.AsGet(), 1425 autorest.WithBaseURL(client.BaseURI), 1426 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/connections", pathParameters), 1427 autorest.WithQueryParameters(queryParameters)) 1428 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1429} 1430 1431// ListConnectionsSender sends the ListConnections request. The method will close the 1432// http.Response Body if it receives an error. 1433func (client VirtualNetworkGatewaysClient) ListConnectionsSender(req *http.Request) (*http.Response, error) { 1434 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1435} 1436 1437// ListConnectionsResponder handles the response to the ListConnections request. The method always 1438// closes the http.Response Body. 1439func (client VirtualNetworkGatewaysClient) ListConnectionsResponder(resp *http.Response) (result VirtualNetworkGatewayListConnectionsResult, err error) { 1440 err = autorest.Respond( 1441 resp, 1442 azure.WithErrorUnlessStatusCode(http.StatusOK), 1443 autorest.ByUnmarshallingJSON(&result), 1444 autorest.ByClosing()) 1445 result.Response = autorest.Response{Response: resp} 1446 return 1447} 1448 1449// listConnectionsNextResults retrieves the next set of results, if any. 1450func (client VirtualNetworkGatewaysClient) listConnectionsNextResults(ctx context.Context, lastResults VirtualNetworkGatewayListConnectionsResult) (result VirtualNetworkGatewayListConnectionsResult, err error) { 1451 req, err := lastResults.virtualNetworkGatewayListConnectionsResultPreparer(ctx) 1452 if err != nil { 1453 return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", nil, "Failure preparing next results request") 1454 } 1455 if req == nil { 1456 return 1457 } 1458 resp, err := client.ListConnectionsSender(req) 1459 if err != nil { 1460 result.Response = autorest.Response{Response: resp} 1461 return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", resp, "Failure sending next results request") 1462 } 1463 result, err = client.ListConnectionsResponder(resp) 1464 if err != nil { 1465 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", resp, "Failure responding to next results request") 1466 } 1467 return 1468} 1469 1470// ListConnectionsComplete enumerates all values, automatically crossing page boundaries as required. 1471func (client VirtualNetworkGatewaysClient) ListConnectionsComplete(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewayListConnectionsResultIterator, err error) { 1472 if tracing.IsEnabled() { 1473 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.ListConnections") 1474 defer func() { 1475 sc := -1 1476 if result.Response().Response.Response != nil { 1477 sc = result.page.Response().Response.Response.StatusCode 1478 } 1479 tracing.EndSpan(ctx, sc, err) 1480 }() 1481 } 1482 result.page, err = client.ListConnections(ctx, resourceGroupName, virtualNetworkGatewayName) 1483 return 1484} 1485 1486// Reset resets the primary of the virtual network gateway in the specified resource group. 1487// Parameters: 1488// resourceGroupName - the name of the resource group. 1489// virtualNetworkGatewayName - the name of the virtual network gateway. 1490// gatewayVip - virtual network gateway vip address supplied to the begin reset of the active-active feature 1491// enabled gateway. 1492func (client VirtualNetworkGatewaysClient) Reset(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, gatewayVip string) (result VirtualNetworkGatewaysResetFuture, err error) { 1493 if tracing.IsEnabled() { 1494 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Reset") 1495 defer func() { 1496 sc := -1 1497 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1498 sc = result.FutureAPI.Response().StatusCode 1499 } 1500 tracing.EndSpan(ctx, sc, err) 1501 }() 1502 } 1503 req, err := client.ResetPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, gatewayVip) 1504 if err != nil { 1505 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Reset", nil, "Failure preparing request") 1506 return 1507 } 1508 1509 result, err = client.ResetSender(req) 1510 if err != nil { 1511 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Reset", nil, "Failure sending request") 1512 return 1513 } 1514 1515 return 1516} 1517 1518// ResetPreparer prepares the Reset request. 1519func (client VirtualNetworkGatewaysClient) ResetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, gatewayVip string) (*http.Request, error) { 1520 pathParameters := map[string]interface{}{ 1521 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1522 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1523 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1524 } 1525 1526 const APIVersion = "2020-06-01" 1527 queryParameters := map[string]interface{}{ 1528 "api-version": APIVersion, 1529 } 1530 if len(gatewayVip) > 0 { 1531 queryParameters["gatewayVip"] = autorest.Encode("query", gatewayVip) 1532 } 1533 1534 preparer := autorest.CreatePreparer( 1535 autorest.AsPost(), 1536 autorest.WithBaseURL(client.BaseURI), 1537 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/reset", pathParameters), 1538 autorest.WithQueryParameters(queryParameters)) 1539 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1540} 1541 1542// ResetSender sends the Reset request. The method will close the 1543// http.Response Body if it receives an error. 1544func (client VirtualNetworkGatewaysClient) ResetSender(req *http.Request) (future VirtualNetworkGatewaysResetFuture, err error) { 1545 var resp *http.Response 1546 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1547 if err != nil { 1548 return 1549 } 1550 var azf azure.Future 1551 azf, err = azure.NewFutureFromResponse(resp) 1552 future.FutureAPI = &azf 1553 future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) { 1554 var done bool 1555 done, err = future.DoneWithContext(context.Background(), client) 1556 if err != nil { 1557 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", future.Response(), "Polling failure") 1558 return 1559 } 1560 if !done { 1561 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysResetFuture") 1562 return 1563 } 1564 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1565 vng.Response.Response, err = future.GetResult(sender) 1566 if vng.Response.Response == nil && err == nil { 1567 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", nil, "received nil response and error") 1568 } 1569 if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent { 1570 vng, err = client.ResetResponder(vng.Response.Response) 1571 if err != nil { 1572 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", vng.Response.Response, "Failure responding to request") 1573 } 1574 } 1575 return 1576 } 1577 return 1578} 1579 1580// ResetResponder handles the response to the Reset request. The method always 1581// closes the http.Response Body. 1582func (client VirtualNetworkGatewaysClient) ResetResponder(resp *http.Response) (result VirtualNetworkGateway, err error) { 1583 err = autorest.Respond( 1584 resp, 1585 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1586 autorest.ByUnmarshallingJSON(&result), 1587 autorest.ByClosing()) 1588 result.Response = autorest.Response{Response: resp} 1589 return 1590} 1591 1592// ResetVpnClientSharedKey resets the VPN client shared key of the virtual network gateway in the specified resource 1593// group. 1594// Parameters: 1595// resourceGroupName - the name of the resource group. 1596// virtualNetworkGatewayName - the name of the virtual network gateway. 1597func (client VirtualNetworkGatewaysClient) ResetVpnClientSharedKey(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysResetVpnClientSharedKeyFuture, err error) { 1598 if tracing.IsEnabled() { 1599 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.ResetVpnClientSharedKey") 1600 defer func() { 1601 sc := -1 1602 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1603 sc = result.FutureAPI.Response().StatusCode 1604 } 1605 tracing.EndSpan(ctx, sc, err) 1606 }() 1607 } 1608 req, err := client.ResetVpnClientSharedKeyPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 1609 if err != nil { 1610 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ResetVpnClientSharedKey", nil, "Failure preparing request") 1611 return 1612 } 1613 1614 result, err = client.ResetVpnClientSharedKeySender(req) 1615 if err != nil { 1616 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ResetVpnClientSharedKey", nil, "Failure sending request") 1617 return 1618 } 1619 1620 return 1621} 1622 1623// ResetVpnClientSharedKeyPreparer prepares the ResetVpnClientSharedKey request. 1624func (client VirtualNetworkGatewaysClient) ResetVpnClientSharedKeyPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 1625 pathParameters := map[string]interface{}{ 1626 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1627 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1628 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1629 } 1630 1631 const APIVersion = "2020-06-01" 1632 queryParameters := map[string]interface{}{ 1633 "api-version": APIVersion, 1634 } 1635 1636 preparer := autorest.CreatePreparer( 1637 autorest.AsPost(), 1638 autorest.WithBaseURL(client.BaseURI), 1639 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/resetvpnclientsharedkey", pathParameters), 1640 autorest.WithQueryParameters(queryParameters)) 1641 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1642} 1643 1644// ResetVpnClientSharedKeySender sends the ResetVpnClientSharedKey request. The method will close the 1645// http.Response Body if it receives an error. 1646func (client VirtualNetworkGatewaysClient) ResetVpnClientSharedKeySender(req *http.Request) (future VirtualNetworkGatewaysResetVpnClientSharedKeyFuture, err error) { 1647 var resp *http.Response 1648 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1649 if err != nil { 1650 return 1651 } 1652 var azf azure.Future 1653 azf, err = azure.NewFutureFromResponse(resp) 1654 future.FutureAPI = &azf 1655 future.Result = func(client VirtualNetworkGatewaysClient) (ar autorest.Response, err error) { 1656 var done bool 1657 done, err = future.DoneWithContext(context.Background(), client) 1658 if err != nil { 1659 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetVpnClientSharedKeyFuture", "Result", future.Response(), "Polling failure") 1660 return 1661 } 1662 if !done { 1663 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysResetVpnClientSharedKeyFuture") 1664 return 1665 } 1666 ar.Response = future.Response() 1667 return 1668 } 1669 return 1670} 1671 1672// ResetVpnClientSharedKeyResponder handles the response to the ResetVpnClientSharedKey request. The method always 1673// closes the http.Response Body. 1674func (client VirtualNetworkGatewaysClient) ResetVpnClientSharedKeyResponder(resp *http.Response) (result autorest.Response, err error) { 1675 err = autorest.Respond( 1676 resp, 1677 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1678 autorest.ByClosing()) 1679 result.Response = resp 1680 return 1681} 1682 1683// SetVpnclientIpsecParameters the Set VpnclientIpsecParameters operation sets the vpnclient ipsec policy for P2S 1684// client of virtual network gateway in the specified resource group through Network resource provider. 1685// Parameters: 1686// resourceGroupName - the name of the resource group. 1687// virtualNetworkGatewayName - the name of the virtual network gateway. 1688// vpnclientIpsecParams - parameters supplied to the Begin Set vpnclient ipsec parameters of Virtual Network 1689// Gateway P2S client operation through Network resource provider. 1690func (client VirtualNetworkGatewaysClient) SetVpnclientIpsecParameters(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, vpnclientIpsecParams VpnClientIPsecParameters) (result VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture, err error) { 1691 if tracing.IsEnabled() { 1692 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.SetVpnclientIpsecParameters") 1693 defer func() { 1694 sc := -1 1695 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1696 sc = result.FutureAPI.Response().StatusCode 1697 } 1698 tracing.EndSpan(ctx, sc, err) 1699 }() 1700 } 1701 if err := validation.Validate([]validation.Validation{ 1702 {TargetValue: vpnclientIpsecParams, 1703 Constraints: []validation.Constraint{{Target: "vpnclientIpsecParams.SaLifeTimeSeconds", Name: validation.Null, Rule: true, Chain: nil}, 1704 {Target: "vpnclientIpsecParams.SaDataSizeKilobytes", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 1705 return result, validation.NewError("network.VirtualNetworkGatewaysClient", "SetVpnclientIpsecParameters", err.Error()) 1706 } 1707 1708 req, err := client.SetVpnclientIpsecParametersPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, vpnclientIpsecParams) 1709 if err != nil { 1710 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SetVpnclientIpsecParameters", nil, "Failure preparing request") 1711 return 1712 } 1713 1714 result, err = client.SetVpnclientIpsecParametersSender(req) 1715 if err != nil { 1716 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SetVpnclientIpsecParameters", nil, "Failure sending request") 1717 return 1718 } 1719 1720 return 1721} 1722 1723// SetVpnclientIpsecParametersPreparer prepares the SetVpnclientIpsecParameters request. 1724func (client VirtualNetworkGatewaysClient) SetVpnclientIpsecParametersPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, vpnclientIpsecParams VpnClientIPsecParameters) (*http.Request, error) { 1725 pathParameters := map[string]interface{}{ 1726 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1727 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1728 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1729 } 1730 1731 const APIVersion = "2020-06-01" 1732 queryParameters := map[string]interface{}{ 1733 "api-version": APIVersion, 1734 } 1735 1736 preparer := autorest.CreatePreparer( 1737 autorest.AsContentType("application/json; charset=utf-8"), 1738 autorest.AsPost(), 1739 autorest.WithBaseURL(client.BaseURI), 1740 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/setvpnclientipsecparameters", pathParameters), 1741 autorest.WithJSON(vpnclientIpsecParams), 1742 autorest.WithQueryParameters(queryParameters)) 1743 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1744} 1745 1746// SetVpnclientIpsecParametersSender sends the SetVpnclientIpsecParameters request. The method will close the 1747// http.Response Body if it receives an error. 1748func (client VirtualNetworkGatewaysClient) SetVpnclientIpsecParametersSender(req *http.Request) (future VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture, err error) { 1749 var resp *http.Response 1750 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1751 if err != nil { 1752 return 1753 } 1754 var azf azure.Future 1755 azf, err = azure.NewFutureFromResponse(resp) 1756 future.FutureAPI = &azf 1757 future.Result = func(client VirtualNetworkGatewaysClient) (vcipp VpnClientIPsecParameters, err error) { 1758 var done bool 1759 done, err = future.DoneWithContext(context.Background(), client) 1760 if err != nil { 1761 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture", "Result", future.Response(), "Polling failure") 1762 return 1763 } 1764 if !done { 1765 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture") 1766 return 1767 } 1768 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1769 vcipp.Response.Response, err = future.GetResult(sender) 1770 if vcipp.Response.Response == nil && err == nil { 1771 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture", "Result", nil, "received nil response and error") 1772 } 1773 if err == nil && vcipp.Response.Response.StatusCode != http.StatusNoContent { 1774 vcipp, err = client.SetVpnclientIpsecParametersResponder(vcipp.Response.Response) 1775 if err != nil { 1776 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture", "Result", vcipp.Response.Response, "Failure responding to request") 1777 } 1778 } 1779 return 1780 } 1781 return 1782} 1783 1784// SetVpnclientIpsecParametersResponder handles the response to the SetVpnclientIpsecParameters request. The method always 1785// closes the http.Response Body. 1786func (client VirtualNetworkGatewaysClient) SetVpnclientIpsecParametersResponder(resp *http.Response) (result VpnClientIPsecParameters, err error) { 1787 err = autorest.Respond( 1788 resp, 1789 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1790 autorest.ByUnmarshallingJSON(&result), 1791 autorest.ByClosing()) 1792 result.Response = autorest.Response{Response: resp} 1793 return 1794} 1795 1796// StartPacketCapture starts packet capture on virtual network gateway in the specified resource group. 1797// Parameters: 1798// resourceGroupName - the name of the resource group. 1799// virtualNetworkGatewayName - the name of the virtual network gateway. 1800// parameters - virtual network gateway packet capture parameters supplied to start packet capture on gateway. 1801func (client VirtualNetworkGatewaysClient) StartPacketCapture(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters *VpnPacketCaptureStartParameters) (result VirtualNetworkGatewaysStartPacketCaptureFuture, err error) { 1802 if tracing.IsEnabled() { 1803 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.StartPacketCapture") 1804 defer func() { 1805 sc := -1 1806 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1807 sc = result.FutureAPI.Response().StatusCode 1808 } 1809 tracing.EndSpan(ctx, sc, err) 1810 }() 1811 } 1812 req, err := client.StartPacketCapturePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 1813 if err != nil { 1814 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "StartPacketCapture", nil, "Failure preparing request") 1815 return 1816 } 1817 1818 result, err = client.StartPacketCaptureSender(req) 1819 if err != nil { 1820 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "StartPacketCapture", nil, "Failure sending request") 1821 return 1822 } 1823 1824 return 1825} 1826 1827// StartPacketCapturePreparer prepares the StartPacketCapture request. 1828func (client VirtualNetworkGatewaysClient) StartPacketCapturePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters *VpnPacketCaptureStartParameters) (*http.Request, error) { 1829 pathParameters := map[string]interface{}{ 1830 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1831 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1832 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1833 } 1834 1835 const APIVersion = "2020-06-01" 1836 queryParameters := map[string]interface{}{ 1837 "api-version": APIVersion, 1838 } 1839 1840 preparer := autorest.CreatePreparer( 1841 autorest.AsContentType("application/json; charset=utf-8"), 1842 autorest.AsPost(), 1843 autorest.WithBaseURL(client.BaseURI), 1844 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/startPacketCapture", pathParameters), 1845 autorest.WithQueryParameters(queryParameters)) 1846 if parameters != nil { 1847 preparer = autorest.DecoratePreparer(preparer, 1848 autorest.WithJSON(parameters)) 1849 } 1850 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1851} 1852 1853// StartPacketCaptureSender sends the StartPacketCapture request. The method will close the 1854// http.Response Body if it receives an error. 1855func (client VirtualNetworkGatewaysClient) StartPacketCaptureSender(req *http.Request) (future VirtualNetworkGatewaysStartPacketCaptureFuture, err error) { 1856 var resp *http.Response 1857 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1858 if err != nil { 1859 return 1860 } 1861 var azf azure.Future 1862 azf, err = azure.NewFutureFromResponse(resp) 1863 future.FutureAPI = &azf 1864 future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) { 1865 var done bool 1866 done, err = future.DoneWithContext(context.Background(), client) 1867 if err != nil { 1868 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysStartPacketCaptureFuture", "Result", future.Response(), "Polling failure") 1869 return 1870 } 1871 if !done { 1872 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysStartPacketCaptureFuture") 1873 return 1874 } 1875 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1876 s.Response.Response, err = future.GetResult(sender) 1877 if s.Response.Response == nil && err == nil { 1878 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysStartPacketCaptureFuture", "Result", nil, "received nil response and error") 1879 } 1880 if err == nil && s.Response.Response.StatusCode != http.StatusNoContent { 1881 s, err = client.StartPacketCaptureResponder(s.Response.Response) 1882 if err != nil { 1883 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysStartPacketCaptureFuture", "Result", s.Response.Response, "Failure responding to request") 1884 } 1885 } 1886 return 1887 } 1888 return 1889} 1890 1891// StartPacketCaptureResponder handles the response to the StartPacketCapture request. The method always 1892// closes the http.Response Body. 1893func (client VirtualNetworkGatewaysClient) StartPacketCaptureResponder(resp *http.Response) (result String, err error) { 1894 err = autorest.Respond( 1895 resp, 1896 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1897 autorest.ByUnmarshallingJSON(&result), 1898 autorest.ByClosing()) 1899 result.Response = autorest.Response{Response: resp} 1900 return 1901} 1902 1903// StopPacketCapture stops packet capture on virtual network gateway in the specified resource group. 1904// Parameters: 1905// resourceGroupName - the name of the resource group. 1906// virtualNetworkGatewayName - the name of the virtual network gateway. 1907// parameters - virtual network gateway packet capture parameters supplied to stop packet capture on gateway. 1908func (client VirtualNetworkGatewaysClient) StopPacketCapture(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnPacketCaptureStopParameters) (result VirtualNetworkGatewaysStopPacketCaptureFuture, err error) { 1909 if tracing.IsEnabled() { 1910 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.StopPacketCapture") 1911 defer func() { 1912 sc := -1 1913 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1914 sc = result.FutureAPI.Response().StatusCode 1915 } 1916 tracing.EndSpan(ctx, sc, err) 1917 }() 1918 } 1919 req, err := client.StopPacketCapturePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 1920 if err != nil { 1921 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "StopPacketCapture", nil, "Failure preparing request") 1922 return 1923 } 1924 1925 result, err = client.StopPacketCaptureSender(req) 1926 if err != nil { 1927 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "StopPacketCapture", nil, "Failure sending request") 1928 return 1929 } 1930 1931 return 1932} 1933 1934// StopPacketCapturePreparer prepares the StopPacketCapture request. 1935func (client VirtualNetworkGatewaysClient) StopPacketCapturePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnPacketCaptureStopParameters) (*http.Request, error) { 1936 pathParameters := map[string]interface{}{ 1937 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1938 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1939 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1940 } 1941 1942 const APIVersion = "2020-06-01" 1943 queryParameters := map[string]interface{}{ 1944 "api-version": APIVersion, 1945 } 1946 1947 preparer := autorest.CreatePreparer( 1948 autorest.AsContentType("application/json; charset=utf-8"), 1949 autorest.AsPost(), 1950 autorest.WithBaseURL(client.BaseURI), 1951 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/stopPacketCapture", pathParameters), 1952 autorest.WithJSON(parameters), 1953 autorest.WithQueryParameters(queryParameters)) 1954 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1955} 1956 1957// StopPacketCaptureSender sends the StopPacketCapture request. The method will close the 1958// http.Response Body if it receives an error. 1959func (client VirtualNetworkGatewaysClient) StopPacketCaptureSender(req *http.Request) (future VirtualNetworkGatewaysStopPacketCaptureFuture, err error) { 1960 var resp *http.Response 1961 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1962 if err != nil { 1963 return 1964 } 1965 var azf azure.Future 1966 azf, err = azure.NewFutureFromResponse(resp) 1967 future.FutureAPI = &azf 1968 future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) { 1969 var done bool 1970 done, err = future.DoneWithContext(context.Background(), client) 1971 if err != nil { 1972 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysStopPacketCaptureFuture", "Result", future.Response(), "Polling failure") 1973 return 1974 } 1975 if !done { 1976 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysStopPacketCaptureFuture") 1977 return 1978 } 1979 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1980 s.Response.Response, err = future.GetResult(sender) 1981 if s.Response.Response == nil && err == nil { 1982 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysStopPacketCaptureFuture", "Result", nil, "received nil response and error") 1983 } 1984 if err == nil && s.Response.Response.StatusCode != http.StatusNoContent { 1985 s, err = client.StopPacketCaptureResponder(s.Response.Response) 1986 if err != nil { 1987 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysStopPacketCaptureFuture", "Result", s.Response.Response, "Failure responding to request") 1988 } 1989 } 1990 return 1991 } 1992 return 1993} 1994 1995// StopPacketCaptureResponder handles the response to the StopPacketCapture request. The method always 1996// closes the http.Response Body. 1997func (client VirtualNetworkGatewaysClient) StopPacketCaptureResponder(resp *http.Response) (result String, err error) { 1998 err = autorest.Respond( 1999 resp, 2000 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 2001 autorest.ByUnmarshallingJSON(&result), 2002 autorest.ByClosing()) 2003 result.Response = autorest.Response{Response: resp} 2004 return 2005} 2006 2007// SupportedVpnDevices gets a xml format representation for supported vpn devices. 2008// Parameters: 2009// resourceGroupName - the name of the resource group. 2010// virtualNetworkGatewayName - the name of the virtual network gateway. 2011func (client VirtualNetworkGatewaysClient) SupportedVpnDevices(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result String, err error) { 2012 if tracing.IsEnabled() { 2013 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.SupportedVpnDevices") 2014 defer func() { 2015 sc := -1 2016 if result.Response.Response != nil { 2017 sc = result.Response.Response.StatusCode 2018 } 2019 tracing.EndSpan(ctx, sc, err) 2020 }() 2021 } 2022 req, err := client.SupportedVpnDevicesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 2023 if err != nil { 2024 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", nil, "Failure preparing request") 2025 return 2026 } 2027 2028 resp, err := client.SupportedVpnDevicesSender(req) 2029 if err != nil { 2030 result.Response = autorest.Response{Response: resp} 2031 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", resp, "Failure sending request") 2032 return 2033 } 2034 2035 result, err = client.SupportedVpnDevicesResponder(resp) 2036 if err != nil { 2037 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", resp, "Failure responding to request") 2038 return 2039 } 2040 2041 return 2042} 2043 2044// SupportedVpnDevicesPreparer prepares the SupportedVpnDevices request. 2045func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 2046 pathParameters := map[string]interface{}{ 2047 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2048 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2049 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 2050 } 2051 2052 const APIVersion = "2020-06-01" 2053 queryParameters := map[string]interface{}{ 2054 "api-version": APIVersion, 2055 } 2056 2057 preparer := autorest.CreatePreparer( 2058 autorest.AsPost(), 2059 autorest.WithBaseURL(client.BaseURI), 2060 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/supportedvpndevices", pathParameters), 2061 autorest.WithQueryParameters(queryParameters)) 2062 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2063} 2064 2065// SupportedVpnDevicesSender sends the SupportedVpnDevices request. The method will close the 2066// http.Response Body if it receives an error. 2067func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesSender(req *http.Request) (*http.Response, error) { 2068 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2069} 2070 2071// SupportedVpnDevicesResponder handles the response to the SupportedVpnDevices request. The method always 2072// closes the http.Response Body. 2073func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesResponder(resp *http.Response) (result String, err error) { 2074 err = autorest.Respond( 2075 resp, 2076 azure.WithErrorUnlessStatusCode(http.StatusOK), 2077 autorest.ByUnmarshallingJSON(&result.Value), 2078 autorest.ByClosing()) 2079 result.Response = autorest.Response{Response: resp} 2080 return 2081} 2082 2083// UpdateTags updates a virtual network gateway tags. 2084// Parameters: 2085// resourceGroupName - the name of the resource group. 2086// virtualNetworkGatewayName - the name of the virtual network gateway. 2087// parameters - parameters supplied to update virtual network gateway tags. 2088func (client VirtualNetworkGatewaysClient) UpdateTags(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject) (result VirtualNetworkGatewaysUpdateTagsFuture, err error) { 2089 if tracing.IsEnabled() { 2090 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.UpdateTags") 2091 defer func() { 2092 sc := -1 2093 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 2094 sc = result.FutureAPI.Response().StatusCode 2095 } 2096 tracing.EndSpan(ctx, sc, err) 2097 }() 2098 } 2099 req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 2100 if err != nil { 2101 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "UpdateTags", nil, "Failure preparing request") 2102 return 2103 } 2104 2105 result, err = client.UpdateTagsSender(req) 2106 if err != nil { 2107 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "UpdateTags", nil, "Failure sending request") 2108 return 2109 } 2110 2111 return 2112} 2113 2114// UpdateTagsPreparer prepares the UpdateTags request. 2115func (client VirtualNetworkGatewaysClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject) (*http.Request, error) { 2116 pathParameters := map[string]interface{}{ 2117 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2118 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2119 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 2120 } 2121 2122 const APIVersion = "2020-06-01" 2123 queryParameters := map[string]interface{}{ 2124 "api-version": APIVersion, 2125 } 2126 2127 preparer := autorest.CreatePreparer( 2128 autorest.AsContentType("application/json; charset=utf-8"), 2129 autorest.AsPatch(), 2130 autorest.WithBaseURL(client.BaseURI), 2131 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters), 2132 autorest.WithJSON(parameters), 2133 autorest.WithQueryParameters(queryParameters)) 2134 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2135} 2136 2137// UpdateTagsSender sends the UpdateTags request. The method will close the 2138// http.Response Body if it receives an error. 2139func (client VirtualNetworkGatewaysClient) UpdateTagsSender(req *http.Request) (future VirtualNetworkGatewaysUpdateTagsFuture, err error) { 2140 var resp *http.Response 2141 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2142 if err != nil { 2143 return 2144 } 2145 var azf azure.Future 2146 azf, err = azure.NewFutureFromResponse(resp) 2147 future.FutureAPI = &azf 2148 future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) { 2149 var done bool 2150 done, err = future.DoneWithContext(context.Background(), client) 2151 if err != nil { 2152 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", future.Response(), "Polling failure") 2153 return 2154 } 2155 if !done { 2156 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysUpdateTagsFuture") 2157 return 2158 } 2159 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 2160 vng.Response.Response, err = future.GetResult(sender) 2161 if vng.Response.Response == nil && err == nil { 2162 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", nil, "received nil response and error") 2163 } 2164 if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent { 2165 vng, err = client.UpdateTagsResponder(vng.Response.Response) 2166 if err != nil { 2167 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", vng.Response.Response, "Failure responding to request") 2168 } 2169 } 2170 return 2171 } 2172 return 2173} 2174 2175// UpdateTagsResponder handles the response to the UpdateTags request. The method always 2176// closes the http.Response Body. 2177func (client VirtualNetworkGatewaysClient) UpdateTagsResponder(resp *http.Response) (result VirtualNetworkGateway, err error) { 2178 err = autorest.Respond( 2179 resp, 2180 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 2181 autorest.ByUnmarshallingJSON(&result), 2182 autorest.ByClosing()) 2183 result.Response = autorest.Response{Response: resp} 2184 return 2185} 2186 2187// VpnDeviceConfigurationScript gets a xml format representation for vpn device configuration script. 2188// Parameters: 2189// resourceGroupName - the name of the resource group. 2190// virtualNetworkGatewayConnectionName - the name of the virtual network gateway connection for which the 2191// configuration script is generated. 2192// parameters - parameters supplied to the generate vpn device script operation. 2193func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScript(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VpnDeviceScriptParameters) (result String, err error) { 2194 if tracing.IsEnabled() { 2195 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.VpnDeviceConfigurationScript") 2196 defer func() { 2197 sc := -1 2198 if result.Response.Response != nil { 2199 sc = result.Response.Response.StatusCode 2200 } 2201 tracing.EndSpan(ctx, sc, err) 2202 }() 2203 } 2204 req, err := client.VpnDeviceConfigurationScriptPreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName, parameters) 2205 if err != nil { 2206 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", nil, "Failure preparing request") 2207 return 2208 } 2209 2210 resp, err := client.VpnDeviceConfigurationScriptSender(req) 2211 if err != nil { 2212 result.Response = autorest.Response{Response: resp} 2213 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", resp, "Failure sending request") 2214 return 2215 } 2216 2217 result, err = client.VpnDeviceConfigurationScriptResponder(resp) 2218 if err != nil { 2219 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", resp, "Failure responding to request") 2220 return 2221 } 2222 2223 return 2224} 2225 2226// VpnDeviceConfigurationScriptPreparer prepares the VpnDeviceConfigurationScript request. 2227func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VpnDeviceScriptParameters) (*http.Request, error) { 2228 pathParameters := map[string]interface{}{ 2229 "resourceGroupName": autorest.Encode("path", resourceGroupName), 2230 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 2231 "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName), 2232 } 2233 2234 const APIVersion = "2020-06-01" 2235 queryParameters := map[string]interface{}{ 2236 "api-version": APIVersion, 2237 } 2238 2239 preparer := autorest.CreatePreparer( 2240 autorest.AsContentType("application/json; charset=utf-8"), 2241 autorest.AsPost(), 2242 autorest.WithBaseURL(client.BaseURI), 2243 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}/vpndeviceconfigurationscript", pathParameters), 2244 autorest.WithJSON(parameters), 2245 autorest.WithQueryParameters(queryParameters)) 2246 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 2247} 2248 2249// VpnDeviceConfigurationScriptSender sends the VpnDeviceConfigurationScript request. The method will close the 2250// http.Response Body if it receives an error. 2251func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptSender(req *http.Request) (*http.Response, error) { 2252 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 2253} 2254 2255// VpnDeviceConfigurationScriptResponder handles the response to the VpnDeviceConfigurationScript request. The method always 2256// closes the http.Response Body. 2257func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptResponder(resp *http.Response) (result String, err error) { 2258 err = autorest.Respond( 2259 resp, 2260 azure.WithErrorUnlessStatusCode(http.StatusOK), 2261 autorest.ByUnmarshallingJSON(&result.Value), 2262 autorest.ByClosing()) 2263 result.Response = autorest.Response{Response: resp} 2264 return 2265} 2266