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, Chain: nil}}}}); err != nil { 65 return result, validation.NewError("network.VirtualNetworkGatewaysClient", "CreateOrUpdate", err.Error()) 66 } 67 68 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 69 if err != nil { 70 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "CreateOrUpdate", nil, "Failure preparing request") 71 return 72 } 73 74 result, err = client.CreateOrUpdateSender(req) 75 if err != nil { 76 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "CreateOrUpdate", nil, "Failure sending request") 77 return 78 } 79 80 return 81} 82 83// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 84func (client VirtualNetworkGatewaysClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VirtualNetworkGateway) (*http.Request, error) { 85 pathParameters := map[string]interface{}{ 86 "resourceGroupName": autorest.Encode("path", resourceGroupName), 87 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 88 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 89 } 90 91 const APIVersion = "2019-04-01" 92 queryParameters := map[string]interface{}{ 93 "api-version": APIVersion, 94 } 95 96 preparer := autorest.CreatePreparer( 97 autorest.AsContentType("application/json; charset=utf-8"), 98 autorest.AsPut(), 99 autorest.WithBaseURL(client.BaseURI), 100 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters), 101 autorest.WithJSON(parameters), 102 autorest.WithQueryParameters(queryParameters)) 103 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 104} 105 106// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 107// http.Response Body if it receives an error. 108func (client VirtualNetworkGatewaysClient) CreateOrUpdateSender(req *http.Request) (future VirtualNetworkGatewaysCreateOrUpdateFuture, err error) { 109 var resp *http.Response 110 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 111 if err != nil { 112 return 113 } 114 var azf azure.Future 115 azf, err = azure.NewFutureFromResponse(resp) 116 future.FutureAPI = &azf 117 future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) { 118 var done bool 119 done, err = future.DoneWithContext(context.Background(), client) 120 if err != nil { 121 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") 122 return 123 } 124 if !done { 125 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysCreateOrUpdateFuture") 126 return 127 } 128 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 129 vng.Response.Response, err = future.GetResult(sender) 130 if vng.Response.Response == nil && err == nil { 131 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", nil, "received nil response and error") 132 } 133 if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent { 134 vng, err = client.CreateOrUpdateResponder(vng.Response.Response) 135 if err != nil { 136 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysCreateOrUpdateFuture", "Result", vng.Response.Response, "Failure responding to request") 137 } 138 } 139 return 140 } 141 return 142} 143 144// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 145// closes the http.Response Body. 146func (client VirtualNetworkGatewaysClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualNetworkGateway, err error) { 147 err = autorest.Respond( 148 resp, 149 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 150 autorest.ByUnmarshallingJSON(&result), 151 autorest.ByClosing()) 152 result.Response = autorest.Response{Response: resp} 153 return 154} 155 156// Delete deletes the specified virtual network gateway. 157// Parameters: 158// resourceGroupName - the name of the resource group. 159// virtualNetworkGatewayName - the name of the virtual network gateway. 160func (client VirtualNetworkGatewaysClient) Delete(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysDeleteFuture, err error) { 161 if tracing.IsEnabled() { 162 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Delete") 163 defer func() { 164 sc := -1 165 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 166 sc = result.FutureAPI.Response().StatusCode 167 } 168 tracing.EndSpan(ctx, sc, err) 169 }() 170 } 171 req, err := client.DeletePreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 172 if err != nil { 173 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Delete", nil, "Failure preparing request") 174 return 175 } 176 177 result, err = client.DeleteSender(req) 178 if err != nil { 179 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Delete", nil, "Failure sending request") 180 return 181 } 182 183 return 184} 185 186// DeletePreparer prepares the Delete request. 187func (client VirtualNetworkGatewaysClient) DeletePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 188 pathParameters := map[string]interface{}{ 189 "resourceGroupName": autorest.Encode("path", resourceGroupName), 190 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 191 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 192 } 193 194 const APIVersion = "2019-04-01" 195 queryParameters := map[string]interface{}{ 196 "api-version": APIVersion, 197 } 198 199 preparer := autorest.CreatePreparer( 200 autorest.AsDelete(), 201 autorest.WithBaseURL(client.BaseURI), 202 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters), 203 autorest.WithQueryParameters(queryParameters)) 204 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 205} 206 207// DeleteSender sends the Delete request. The method will close the 208// http.Response Body if it receives an error. 209func (client VirtualNetworkGatewaysClient) DeleteSender(req *http.Request) (future VirtualNetworkGatewaysDeleteFuture, err error) { 210 var resp *http.Response 211 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 212 if err != nil { 213 return 214 } 215 var azf azure.Future 216 azf, err = azure.NewFutureFromResponse(resp) 217 future.FutureAPI = &azf 218 future.Result = func(client VirtualNetworkGatewaysClient) (ar autorest.Response, err error) { 219 var done bool 220 done, err = future.DoneWithContext(context.Background(), client) 221 if err != nil { 222 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysDeleteFuture", "Result", future.Response(), "Polling failure") 223 return 224 } 225 if !done { 226 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysDeleteFuture") 227 return 228 } 229 ar.Response = future.Response() 230 return 231 } 232 return 233} 234 235// DeleteResponder handles the response to the Delete request. The method always 236// closes the http.Response Body. 237func (client VirtualNetworkGatewaysClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 238 err = autorest.Respond( 239 resp, 240 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 241 autorest.ByClosing()) 242 result.Response = resp 243 return 244} 245 246// Generatevpnclientpackage generates VPN client package for P2S client of the virtual network gateway in the specified 247// resource group. 248// Parameters: 249// resourceGroupName - the name of the resource group. 250// virtualNetworkGatewayName - the name of the virtual network gateway. 251// parameters - parameters supplied to the generate virtual network gateway VPN client package operation. 252func (client VirtualNetworkGatewaysClient) Generatevpnclientpackage(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (result VirtualNetworkGatewaysGeneratevpnclientpackageFuture, err error) { 253 if tracing.IsEnabled() { 254 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Generatevpnclientpackage") 255 defer func() { 256 sc := -1 257 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 258 sc = result.FutureAPI.Response().StatusCode 259 } 260 tracing.EndSpan(ctx, sc, err) 261 }() 262 } 263 req, err := client.GeneratevpnclientpackagePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 264 if err != nil { 265 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Generatevpnclientpackage", nil, "Failure preparing request") 266 return 267 } 268 269 result, err = client.GeneratevpnclientpackageSender(req) 270 if err != nil { 271 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Generatevpnclientpackage", nil, "Failure sending request") 272 return 273 } 274 275 return 276} 277 278// GeneratevpnclientpackagePreparer prepares the Generatevpnclientpackage request. 279func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackagePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (*http.Request, error) { 280 pathParameters := map[string]interface{}{ 281 "resourceGroupName": autorest.Encode("path", resourceGroupName), 282 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 283 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 284 } 285 286 const APIVersion = "2019-04-01" 287 queryParameters := map[string]interface{}{ 288 "api-version": APIVersion, 289 } 290 291 preparer := autorest.CreatePreparer( 292 autorest.AsContentType("application/json; charset=utf-8"), 293 autorest.AsPost(), 294 autorest.WithBaseURL(client.BaseURI), 295 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnclientpackage", pathParameters), 296 autorest.WithJSON(parameters), 297 autorest.WithQueryParameters(queryParameters)) 298 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 299} 300 301// GeneratevpnclientpackageSender sends the Generatevpnclientpackage request. The method will close the 302// http.Response Body if it receives an error. 303func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackageSender(req *http.Request) (future VirtualNetworkGatewaysGeneratevpnclientpackageFuture, err error) { 304 var resp *http.Response 305 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 306 if err != nil { 307 return 308 } 309 var azf azure.Future 310 azf, err = azure.NewFutureFromResponse(resp) 311 future.FutureAPI = &azf 312 future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) { 313 var done bool 314 done, err = future.DoneWithContext(context.Background(), client) 315 if err != nil { 316 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", future.Response(), "Polling failure") 317 return 318 } 319 if !done { 320 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture") 321 return 322 } 323 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 324 s.Response.Response, err = future.GetResult(sender) 325 if s.Response.Response == nil && err == nil { 326 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", nil, "received nil response and error") 327 } 328 if err == nil && s.Response.Response.StatusCode != http.StatusNoContent { 329 s, err = client.GeneratevpnclientpackageResponder(s.Response.Response) 330 if err != nil { 331 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGeneratevpnclientpackageFuture", "Result", s.Response.Response, "Failure responding to request") 332 } 333 } 334 return 335 } 336 return 337} 338 339// GeneratevpnclientpackageResponder handles the response to the Generatevpnclientpackage request. The method always 340// closes the http.Response Body. 341func (client VirtualNetworkGatewaysClient) GeneratevpnclientpackageResponder(resp *http.Response) (result String, err error) { 342 err = autorest.Respond( 343 resp, 344 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 345 autorest.ByUnmarshallingJSON(&result), 346 autorest.ByClosing()) 347 result.Response = autorest.Response{Response: resp} 348 return 349} 350 351// GenerateVpnProfile generates VPN profile for P2S client of the virtual network gateway in the specified resource 352// group. Used for IKEV2 and radius based authentication. 353// Parameters: 354// resourceGroupName - the name of the resource group. 355// virtualNetworkGatewayName - the name of the virtual network gateway. 356// parameters - parameters supplied to the generate virtual network gateway VPN client package operation. 357func (client VirtualNetworkGatewaysClient) GenerateVpnProfile(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (result VirtualNetworkGatewaysGenerateVpnProfileFuture, err error) { 358 if tracing.IsEnabled() { 359 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GenerateVpnProfile") 360 defer func() { 361 sc := -1 362 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 363 sc = result.FutureAPI.Response().StatusCode 364 } 365 tracing.EndSpan(ctx, sc, err) 366 }() 367 } 368 req, err := client.GenerateVpnProfilePreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 369 if err != nil { 370 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GenerateVpnProfile", nil, "Failure preparing request") 371 return 372 } 373 374 result, err = client.GenerateVpnProfileSender(req) 375 if err != nil { 376 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GenerateVpnProfile", nil, "Failure sending request") 377 return 378 } 379 380 return 381} 382 383// GenerateVpnProfilePreparer prepares the GenerateVpnProfile request. 384func (client VirtualNetworkGatewaysClient) GenerateVpnProfilePreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VpnClientParameters) (*http.Request, error) { 385 pathParameters := map[string]interface{}{ 386 "resourceGroupName": autorest.Encode("path", resourceGroupName), 387 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 388 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 389 } 390 391 const APIVersion = "2019-04-01" 392 queryParameters := map[string]interface{}{ 393 "api-version": APIVersion, 394 } 395 396 preparer := autorest.CreatePreparer( 397 autorest.AsContentType("application/json; charset=utf-8"), 398 autorest.AsPost(), 399 autorest.WithBaseURL(client.BaseURI), 400 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnprofile", pathParameters), 401 autorest.WithJSON(parameters), 402 autorest.WithQueryParameters(queryParameters)) 403 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 404} 405 406// GenerateVpnProfileSender sends the GenerateVpnProfile request. The method will close the 407// http.Response Body if it receives an error. 408func (client VirtualNetworkGatewaysClient) GenerateVpnProfileSender(req *http.Request) (future VirtualNetworkGatewaysGenerateVpnProfileFuture, err error) { 409 var resp *http.Response 410 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 411 if err != nil { 412 return 413 } 414 var azf azure.Future 415 azf, err = azure.NewFutureFromResponse(resp) 416 future.FutureAPI = &azf 417 future.Result = func(client VirtualNetworkGatewaysClient) (s String, err error) { 418 var done bool 419 done, err = future.DoneWithContext(context.Background(), client) 420 if err != nil { 421 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", future.Response(), "Polling failure") 422 return 423 } 424 if !done { 425 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGenerateVpnProfileFuture") 426 return 427 } 428 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 429 s.Response.Response, err = future.GetResult(sender) 430 if s.Response.Response == nil && err == nil { 431 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", nil, "received nil response and error") 432 } 433 if err == nil && s.Response.Response.StatusCode != http.StatusNoContent { 434 s, err = client.GenerateVpnProfileResponder(s.Response.Response) 435 if err != nil { 436 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGenerateVpnProfileFuture", "Result", s.Response.Response, "Failure responding to request") 437 } 438 } 439 return 440 } 441 return 442} 443 444// GenerateVpnProfileResponder handles the response to the GenerateVpnProfile request. The method always 445// closes the http.Response Body. 446func (client VirtualNetworkGatewaysClient) GenerateVpnProfileResponder(resp *http.Response) (result String, err error) { 447 err = autorest.Respond( 448 resp, 449 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 450 autorest.ByUnmarshallingJSON(&result), 451 autorest.ByClosing()) 452 result.Response = autorest.Response{Response: resp} 453 return 454} 455 456// Get gets the specified virtual network gateway by resource group. 457// Parameters: 458// resourceGroupName - the name of the resource group. 459// virtualNetworkGatewayName - the name of the virtual network gateway. 460func (client VirtualNetworkGatewaysClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGateway, err error) { 461 if tracing.IsEnabled() { 462 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Get") 463 defer func() { 464 sc := -1 465 if result.Response.Response != nil { 466 sc = result.Response.Response.StatusCode 467 } 468 tracing.EndSpan(ctx, sc, err) 469 }() 470 } 471 req, err := client.GetPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 472 if err != nil { 473 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", nil, "Failure preparing request") 474 return 475 } 476 477 resp, err := client.GetSender(req) 478 if err != nil { 479 result.Response = autorest.Response{Response: resp} 480 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", resp, "Failure sending request") 481 return 482 } 483 484 result, err = client.GetResponder(resp) 485 if err != nil { 486 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Get", resp, "Failure responding to request") 487 return 488 } 489 490 return 491} 492 493// GetPreparer prepares the Get request. 494func (client VirtualNetworkGatewaysClient) GetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 495 pathParameters := map[string]interface{}{ 496 "resourceGroupName": autorest.Encode("path", resourceGroupName), 497 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 498 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 499 } 500 501 const APIVersion = "2019-04-01" 502 queryParameters := map[string]interface{}{ 503 "api-version": APIVersion, 504 } 505 506 preparer := autorest.CreatePreparer( 507 autorest.AsGet(), 508 autorest.WithBaseURL(client.BaseURI), 509 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters), 510 autorest.WithQueryParameters(queryParameters)) 511 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 512} 513 514// GetSender sends the Get request. The method will close the 515// http.Response Body if it receives an error. 516func (client VirtualNetworkGatewaysClient) GetSender(req *http.Request) (*http.Response, error) { 517 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 518} 519 520// GetResponder handles the response to the Get request. The method always 521// closes the http.Response Body. 522func (client VirtualNetworkGatewaysClient) GetResponder(resp *http.Response) (result VirtualNetworkGateway, err error) { 523 err = autorest.Respond( 524 resp, 525 azure.WithErrorUnlessStatusCode(http.StatusOK), 526 autorest.ByUnmarshallingJSON(&result), 527 autorest.ByClosing()) 528 result.Response = autorest.Response{Response: resp} 529 return 530} 531 532// GetAdvertisedRoutes this operation retrieves a list of routes the virtual network gateway is advertising to the 533// specified peer. 534// Parameters: 535// resourceGroupName - the name of the resource group. 536// virtualNetworkGatewayName - the name of the virtual network gateway. 537// peer - the IP address of the peer. 538func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (result VirtualNetworkGatewaysGetAdvertisedRoutesFuture, err error) { 539 if tracing.IsEnabled() { 540 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetAdvertisedRoutes") 541 defer func() { 542 sc := -1 543 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 544 sc = result.FutureAPI.Response().StatusCode 545 } 546 tracing.EndSpan(ctx, sc, err) 547 }() 548 } 549 req, err := client.GetAdvertisedRoutesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, peer) 550 if err != nil { 551 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetAdvertisedRoutes", nil, "Failure preparing request") 552 return 553 } 554 555 result, err = client.GetAdvertisedRoutesSender(req) 556 if err != nil { 557 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetAdvertisedRoutes", nil, "Failure sending request") 558 return 559 } 560 561 return 562} 563 564// GetAdvertisedRoutesPreparer prepares the GetAdvertisedRoutes request. 565func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (*http.Request, error) { 566 pathParameters := map[string]interface{}{ 567 "resourceGroupName": autorest.Encode("path", resourceGroupName), 568 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 569 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 570 } 571 572 const APIVersion = "2019-04-01" 573 queryParameters := map[string]interface{}{ 574 "api-version": APIVersion, 575 "peer": autorest.Encode("query", peer), 576 } 577 578 preparer := autorest.CreatePreparer( 579 autorest.AsPost(), 580 autorest.WithBaseURL(client.BaseURI), 581 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getAdvertisedRoutes", pathParameters), 582 autorest.WithQueryParameters(queryParameters)) 583 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 584} 585 586// GetAdvertisedRoutesSender sends the GetAdvertisedRoutes request. The method will close the 587// http.Response Body if it receives an error. 588func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesSender(req *http.Request) (future VirtualNetworkGatewaysGetAdvertisedRoutesFuture, err error) { 589 var resp *http.Response 590 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 591 if err != nil { 592 return 593 } 594 var azf azure.Future 595 azf, err = azure.NewFutureFromResponse(resp) 596 future.FutureAPI = &azf 597 future.Result = func(client VirtualNetworkGatewaysClient) (grlr GatewayRouteListResult, err error) { 598 var done bool 599 done, err = future.DoneWithContext(context.Background(), client) 600 if err != nil { 601 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", future.Response(), "Polling failure") 602 return 603 } 604 if !done { 605 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture") 606 return 607 } 608 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 609 grlr.Response.Response, err = future.GetResult(sender) 610 if grlr.Response.Response == nil && err == nil { 611 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", nil, "received nil response and error") 612 } 613 if err == nil && grlr.Response.Response.StatusCode != http.StatusNoContent { 614 grlr, err = client.GetAdvertisedRoutesResponder(grlr.Response.Response) 615 if err != nil { 616 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetAdvertisedRoutesFuture", "Result", grlr.Response.Response, "Failure responding to request") 617 } 618 } 619 return 620 } 621 return 622} 623 624// GetAdvertisedRoutesResponder handles the response to the GetAdvertisedRoutes request. The method always 625// closes the http.Response Body. 626func (client VirtualNetworkGatewaysClient) GetAdvertisedRoutesResponder(resp *http.Response) (result GatewayRouteListResult, err error) { 627 err = autorest.Respond( 628 resp, 629 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 630 autorest.ByUnmarshallingJSON(&result), 631 autorest.ByClosing()) 632 result.Response = autorest.Response{Response: resp} 633 return 634} 635 636// GetBgpPeerStatus the GetBgpPeerStatus operation retrieves the status of all BGP peers. 637// Parameters: 638// resourceGroupName - the name of the resource group. 639// virtualNetworkGatewayName - the name of the virtual network gateway. 640// peer - the IP address of the peer to retrieve the status of. 641func (client VirtualNetworkGatewaysClient) GetBgpPeerStatus(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (result VirtualNetworkGatewaysGetBgpPeerStatusFuture, err error) { 642 if tracing.IsEnabled() { 643 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetBgpPeerStatus") 644 defer func() { 645 sc := -1 646 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 647 sc = result.FutureAPI.Response().StatusCode 648 } 649 tracing.EndSpan(ctx, sc, err) 650 }() 651 } 652 req, err := client.GetBgpPeerStatusPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, peer) 653 if err != nil { 654 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetBgpPeerStatus", nil, "Failure preparing request") 655 return 656 } 657 658 result, err = client.GetBgpPeerStatusSender(req) 659 if err != nil { 660 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetBgpPeerStatus", nil, "Failure sending request") 661 return 662 } 663 664 return 665} 666 667// GetBgpPeerStatusPreparer prepares the GetBgpPeerStatus request. 668func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string) (*http.Request, error) { 669 pathParameters := map[string]interface{}{ 670 "resourceGroupName": autorest.Encode("path", resourceGroupName), 671 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 672 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 673 } 674 675 const APIVersion = "2019-04-01" 676 queryParameters := map[string]interface{}{ 677 "api-version": APIVersion, 678 } 679 if len(peer) > 0 { 680 queryParameters["peer"] = autorest.Encode("query", peer) 681 } 682 683 preparer := autorest.CreatePreparer( 684 autorest.AsPost(), 685 autorest.WithBaseURL(client.BaseURI), 686 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getBgpPeerStatus", pathParameters), 687 autorest.WithQueryParameters(queryParameters)) 688 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 689} 690 691// GetBgpPeerStatusSender sends the GetBgpPeerStatus request. The method will close the 692// http.Response Body if it receives an error. 693func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusSender(req *http.Request) (future VirtualNetworkGatewaysGetBgpPeerStatusFuture, err error) { 694 var resp *http.Response 695 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 696 if err != nil { 697 return 698 } 699 var azf azure.Future 700 azf, err = azure.NewFutureFromResponse(resp) 701 future.FutureAPI = &azf 702 future.Result = func(client VirtualNetworkGatewaysClient) (bpslr BgpPeerStatusListResult, err error) { 703 var done bool 704 done, err = future.DoneWithContext(context.Background(), client) 705 if err != nil { 706 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", future.Response(), "Polling failure") 707 return 708 } 709 if !done { 710 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetBgpPeerStatusFuture") 711 return 712 } 713 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 714 bpslr.Response.Response, err = future.GetResult(sender) 715 if bpslr.Response.Response == nil && err == nil { 716 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", nil, "received nil response and error") 717 } 718 if err == nil && bpslr.Response.Response.StatusCode != http.StatusNoContent { 719 bpslr, err = client.GetBgpPeerStatusResponder(bpslr.Response.Response) 720 if err != nil { 721 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetBgpPeerStatusFuture", "Result", bpslr.Response.Response, "Failure responding to request") 722 } 723 } 724 return 725 } 726 return 727} 728 729// GetBgpPeerStatusResponder handles the response to the GetBgpPeerStatus request. The method always 730// closes the http.Response Body. 731func (client VirtualNetworkGatewaysClient) GetBgpPeerStatusResponder(resp *http.Response) (result BgpPeerStatusListResult, err error) { 732 err = autorest.Respond( 733 resp, 734 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 735 autorest.ByUnmarshallingJSON(&result), 736 autorest.ByClosing()) 737 result.Response = autorest.Response{Response: resp} 738 return 739} 740 741// GetLearnedRoutes this operation retrieves a list of routes the virtual network gateway has learned, including routes 742// learned from BGP peers. 743// Parameters: 744// resourceGroupName - the name of the resource group. 745// virtualNetworkGatewayName - the name of the virtual network gateway. 746func (client VirtualNetworkGatewaysClient) GetLearnedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetLearnedRoutesFuture, err error) { 747 if tracing.IsEnabled() { 748 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetLearnedRoutes") 749 defer func() { 750 sc := -1 751 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 752 sc = result.FutureAPI.Response().StatusCode 753 } 754 tracing.EndSpan(ctx, sc, err) 755 }() 756 } 757 req, err := client.GetLearnedRoutesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 758 if err != nil { 759 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetLearnedRoutes", nil, "Failure preparing request") 760 return 761 } 762 763 result, err = client.GetLearnedRoutesSender(req) 764 if err != nil { 765 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetLearnedRoutes", nil, "Failure sending request") 766 return 767 } 768 769 return 770} 771 772// GetLearnedRoutesPreparer prepares the GetLearnedRoutes request. 773func (client VirtualNetworkGatewaysClient) GetLearnedRoutesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 774 pathParameters := map[string]interface{}{ 775 "resourceGroupName": autorest.Encode("path", resourceGroupName), 776 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 777 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 778 } 779 780 const APIVersion = "2019-04-01" 781 queryParameters := map[string]interface{}{ 782 "api-version": APIVersion, 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}/getLearnedRoutes", pathParameters), 789 autorest.WithQueryParameters(queryParameters)) 790 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 791} 792 793// GetLearnedRoutesSender sends the GetLearnedRoutes request. The method will close the 794// http.Response Body if it receives an error. 795func (client VirtualNetworkGatewaysClient) GetLearnedRoutesSender(req *http.Request) (future VirtualNetworkGatewaysGetLearnedRoutesFuture, 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) (grlr GatewayRouteListResult, err error) { 805 var done bool 806 done, err = future.DoneWithContext(context.Background(), client) 807 if err != nil { 808 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", future.Response(), "Polling failure") 809 return 810 } 811 if !done { 812 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetLearnedRoutesFuture") 813 return 814 } 815 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 816 grlr.Response.Response, err = future.GetResult(sender) 817 if grlr.Response.Response == nil && err == nil { 818 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", nil, "received nil response and error") 819 } 820 if err == nil && grlr.Response.Response.StatusCode != http.StatusNoContent { 821 grlr, err = client.GetLearnedRoutesResponder(grlr.Response.Response) 822 if err != nil { 823 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetLearnedRoutesFuture", "Result", grlr.Response.Response, "Failure responding to request") 824 } 825 } 826 return 827 } 828 return 829} 830 831// GetLearnedRoutesResponder handles the response to the GetLearnedRoutes request. The method always 832// closes the http.Response Body. 833func (client VirtualNetworkGatewaysClient) GetLearnedRoutesResponder(resp *http.Response) (result GatewayRouteListResult, 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// GetVpnclientConnectionHealth get VPN client connection health detail per P2S client connection of the virtual 844// network gateway in the specified resource group. 845// Parameters: 846// resourceGroupName - the name of the resource group. 847// virtualNetworkGatewayName - the name of the virtual network gateway. 848func (client VirtualNetworkGatewaysClient) GetVpnclientConnectionHealth(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture, err error) { 849 if tracing.IsEnabled() { 850 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetVpnclientConnectionHealth") 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.GetVpnclientConnectionHealthPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 860 if err != nil { 861 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnclientConnectionHealth", nil, "Failure preparing request") 862 return 863 } 864 865 result, err = client.GetVpnclientConnectionHealthSender(req) 866 if err != nil { 867 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnclientConnectionHealth", nil, "Failure sending request") 868 return 869 } 870 871 return 872} 873 874// GetVpnclientConnectionHealthPreparer prepares the GetVpnclientConnectionHealth request. 875func (client VirtualNetworkGatewaysClient) GetVpnclientConnectionHealthPreparer(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 = "2019-04-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}/getVpnClientConnectionHealth", pathParameters), 891 autorest.WithQueryParameters(queryParameters)) 892 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 893} 894 895// GetVpnclientConnectionHealthSender sends the GetVpnclientConnectionHealth request. The method will close the 896// http.Response Body if it receives an error. 897func (client VirtualNetworkGatewaysClient) GetVpnclientConnectionHealthSender(req *http.Request) (future VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture, 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) (vcchdlr VpnClientConnectionHealthDetailListResult, err error) { 907 var done bool 908 done, err = future.DoneWithContext(context.Background(), client) 909 if err != nil { 910 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture", "Result", future.Response(), "Polling failure") 911 return 912 } 913 if !done { 914 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture") 915 return 916 } 917 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 918 vcchdlr.Response.Response, err = future.GetResult(sender) 919 if vcchdlr.Response.Response == nil && err == nil { 920 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture", "Result", nil, "received nil response and error") 921 } 922 if err == nil && vcchdlr.Response.Response.StatusCode != http.StatusNoContent { 923 vcchdlr, err = client.GetVpnclientConnectionHealthResponder(vcchdlr.Response.Response) 924 if err != nil { 925 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientConnectionHealthFuture", "Result", vcchdlr.Response.Response, "Failure responding to request") 926 } 927 } 928 return 929 } 930 return 931} 932 933// GetVpnclientConnectionHealthResponder handles the response to the GetVpnclientConnectionHealth request. The method always 934// closes the http.Response Body. 935func (client VirtualNetworkGatewaysClient) GetVpnclientConnectionHealthResponder(resp *http.Response) (result VpnClientConnectionHealthDetailListResult, 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// GetVpnclientIpsecParameters the Get VpnclientIpsecParameters operation retrieves information about the vpnclient 946// ipsec policy for P2S client of virtual network gateway in the specified resource group through Network resource 947// provider. 948// Parameters: 949// resourceGroupName - the name of the resource group. 950// virtualNetworkGatewayName - the virtual network gateway name. 951func (client VirtualNetworkGatewaysClient) GetVpnclientIpsecParameters(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture, err error) { 952 if tracing.IsEnabled() { 953 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetVpnclientIpsecParameters") 954 defer func() { 955 sc := -1 956 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 957 sc = result.FutureAPI.Response().StatusCode 958 } 959 tracing.EndSpan(ctx, sc, err) 960 }() 961 } 962 req, err := client.GetVpnclientIpsecParametersPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 963 if err != nil { 964 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnclientIpsecParameters", nil, "Failure preparing request") 965 return 966 } 967 968 result, err = client.GetVpnclientIpsecParametersSender(req) 969 if err != nil { 970 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnclientIpsecParameters", nil, "Failure sending request") 971 return 972 } 973 974 return 975} 976 977// GetVpnclientIpsecParametersPreparer prepares the GetVpnclientIpsecParameters request. 978func (client VirtualNetworkGatewaysClient) GetVpnclientIpsecParametersPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 979 pathParameters := map[string]interface{}{ 980 "resourceGroupName": autorest.Encode("path", resourceGroupName), 981 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 982 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 983 } 984 985 const APIVersion = "2019-04-01" 986 queryParameters := map[string]interface{}{ 987 "api-version": APIVersion, 988 } 989 990 preparer := autorest.CreatePreparer( 991 autorest.AsPost(), 992 autorest.WithBaseURL(client.BaseURI), 993 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getvpnclientipsecparameters", pathParameters), 994 autorest.WithQueryParameters(queryParameters)) 995 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 996} 997 998// GetVpnclientIpsecParametersSender sends the GetVpnclientIpsecParameters request. The method will close the 999// http.Response Body if it receives an error. 1000func (client VirtualNetworkGatewaysClient) GetVpnclientIpsecParametersSender(req *http.Request) (future VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture, err error) { 1001 var resp *http.Response 1002 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1003 if err != nil { 1004 return 1005 } 1006 var azf azure.Future 1007 azf, err = azure.NewFutureFromResponse(resp) 1008 future.FutureAPI = &azf 1009 future.Result = func(client VirtualNetworkGatewaysClient) (vcipp VpnClientIPsecParameters, err error) { 1010 var done bool 1011 done, err = future.DoneWithContext(context.Background(), client) 1012 if err != nil { 1013 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture", "Result", future.Response(), "Polling failure") 1014 return 1015 } 1016 if !done { 1017 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture") 1018 return 1019 } 1020 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1021 vcipp.Response.Response, err = future.GetResult(sender) 1022 if vcipp.Response.Response == nil && err == nil { 1023 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture", "Result", nil, "received nil response and error") 1024 } 1025 if err == nil && vcipp.Response.Response.StatusCode != http.StatusNoContent { 1026 vcipp, err = client.GetVpnclientIpsecParametersResponder(vcipp.Response.Response) 1027 if err != nil { 1028 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnclientIpsecParametersFuture", "Result", vcipp.Response.Response, "Failure responding to request") 1029 } 1030 } 1031 return 1032 } 1033 return 1034} 1035 1036// GetVpnclientIpsecParametersResponder handles the response to the GetVpnclientIpsecParameters request. The method always 1037// closes the http.Response Body. 1038func (client VirtualNetworkGatewaysClient) GetVpnclientIpsecParametersResponder(resp *http.Response) (result VpnClientIPsecParameters, err error) { 1039 err = autorest.Respond( 1040 resp, 1041 azure.WithErrorUnlessStatusCode(http.StatusOK), 1042 autorest.ByUnmarshallingJSON(&result), 1043 autorest.ByClosing()) 1044 result.Response = autorest.Response{Response: resp} 1045 return 1046} 1047 1048// GetVpnProfilePackageURL gets pre-generated VPN profile for P2S client of the virtual network gateway in the 1049// specified resource group. The profile needs to be generated first using generateVpnProfile. 1050// Parameters: 1051// resourceGroupName - the name of the resource group. 1052// virtualNetworkGatewayName - the name of the virtual network gateway. 1053func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURL(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysGetVpnProfilePackageURLFuture, err error) { 1054 if tracing.IsEnabled() { 1055 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.GetVpnProfilePackageURL") 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.GetVpnProfilePackageURLPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 1065 if err != nil { 1066 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnProfilePackageURL", nil, "Failure preparing request") 1067 return 1068 } 1069 1070 result, err = client.GetVpnProfilePackageURLSender(req) 1071 if err != nil { 1072 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "GetVpnProfilePackageURL", nil, "Failure sending request") 1073 return 1074 } 1075 1076 return 1077} 1078 1079// GetVpnProfilePackageURLPreparer prepares the GetVpnProfilePackageURL request. 1080func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLPreparer(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 = "2019-04-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}/getvpnprofilepackageurl", pathParameters), 1096 autorest.WithQueryParameters(queryParameters)) 1097 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1098} 1099 1100// GetVpnProfilePackageURLSender sends the GetVpnProfilePackageURL request. The method will close the 1101// http.Response Body if it receives an error. 1102func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLSender(req *http.Request) (future VirtualNetworkGatewaysGetVpnProfilePackageURLFuture, 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) (s String, err error) { 1112 var done bool 1113 done, err = future.DoneWithContext(context.Background(), client) 1114 if err != nil { 1115 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", future.Response(), "Polling failure") 1116 return 1117 } 1118 if !done { 1119 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture") 1120 return 1121 } 1122 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1123 s.Response.Response, err = future.GetResult(sender) 1124 if s.Response.Response == nil && err == nil { 1125 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", nil, "received nil response and error") 1126 } 1127 if err == nil && s.Response.Response.StatusCode != http.StatusNoContent { 1128 s, err = client.GetVpnProfilePackageURLResponder(s.Response.Response) 1129 if err != nil { 1130 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysGetVpnProfilePackageURLFuture", "Result", s.Response.Response, "Failure responding to request") 1131 } 1132 } 1133 return 1134 } 1135 return 1136} 1137 1138// GetVpnProfilePackageURLResponder handles the response to the GetVpnProfilePackageURL request. The method always 1139// closes the http.Response Body. 1140func (client VirtualNetworkGatewaysClient) GetVpnProfilePackageURLResponder(resp *http.Response) (result String, err error) { 1141 err = autorest.Respond( 1142 resp, 1143 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1144 autorest.ByUnmarshallingJSON(&result), 1145 autorest.ByClosing()) 1146 result.Response = autorest.Response{Response: resp} 1147 return 1148} 1149 1150// List gets all virtual network gateways by resource group. 1151// Parameters: 1152// resourceGroupName - the name of the resource group. 1153func (client VirtualNetworkGatewaysClient) List(ctx context.Context, resourceGroupName string) (result VirtualNetworkGatewayListResultPage, err error) { 1154 if tracing.IsEnabled() { 1155 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.List") 1156 defer func() { 1157 sc := -1 1158 if result.vnglr.Response.Response != nil { 1159 sc = result.vnglr.Response.Response.StatusCode 1160 } 1161 tracing.EndSpan(ctx, sc, err) 1162 }() 1163 } 1164 result.fn = client.listNextResults 1165 req, err := client.ListPreparer(ctx, resourceGroupName) 1166 if err != nil { 1167 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", nil, "Failure preparing request") 1168 return 1169 } 1170 1171 resp, err := client.ListSender(req) 1172 if err != nil { 1173 result.vnglr.Response = autorest.Response{Response: resp} 1174 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", resp, "Failure sending request") 1175 return 1176 } 1177 1178 result.vnglr, err = client.ListResponder(resp) 1179 if err != nil { 1180 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "List", resp, "Failure responding to request") 1181 return 1182 } 1183 if result.vnglr.hasNextLink() && result.vnglr.IsEmpty() { 1184 err = result.NextWithContext(ctx) 1185 return 1186 } 1187 1188 return 1189} 1190 1191// ListPreparer prepares the List request. 1192func (client VirtualNetworkGatewaysClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 1193 pathParameters := map[string]interface{}{ 1194 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1195 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1196 } 1197 1198 const APIVersion = "2019-04-01" 1199 queryParameters := map[string]interface{}{ 1200 "api-version": APIVersion, 1201 } 1202 1203 preparer := autorest.CreatePreparer( 1204 autorest.AsGet(), 1205 autorest.WithBaseURL(client.BaseURI), 1206 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways", pathParameters), 1207 autorest.WithQueryParameters(queryParameters)) 1208 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1209} 1210 1211// ListSender sends the List request. The method will close the 1212// http.Response Body if it receives an error. 1213func (client VirtualNetworkGatewaysClient) ListSender(req *http.Request) (*http.Response, error) { 1214 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1215} 1216 1217// ListResponder handles the response to the List request. The method always 1218// closes the http.Response Body. 1219func (client VirtualNetworkGatewaysClient) ListResponder(resp *http.Response) (result VirtualNetworkGatewayListResult, err error) { 1220 err = autorest.Respond( 1221 resp, 1222 azure.WithErrorUnlessStatusCode(http.StatusOK), 1223 autorest.ByUnmarshallingJSON(&result), 1224 autorest.ByClosing()) 1225 result.Response = autorest.Response{Response: resp} 1226 return 1227} 1228 1229// listNextResults retrieves the next set of results, if any. 1230func (client VirtualNetworkGatewaysClient) listNextResults(ctx context.Context, lastResults VirtualNetworkGatewayListResult) (result VirtualNetworkGatewayListResult, err error) { 1231 req, err := lastResults.virtualNetworkGatewayListResultPreparer(ctx) 1232 if err != nil { 1233 return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", nil, "Failure preparing next results request") 1234 } 1235 if req == nil { 1236 return 1237 } 1238 resp, err := client.ListSender(req) 1239 if err != nil { 1240 result.Response = autorest.Response{Response: resp} 1241 return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", resp, "Failure sending next results request") 1242 } 1243 result, err = client.ListResponder(resp) 1244 if err != nil { 1245 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listNextResults", resp, "Failure responding to next results request") 1246 } 1247 return 1248} 1249 1250// ListComplete enumerates all values, automatically crossing page boundaries as required. 1251func (client VirtualNetworkGatewaysClient) ListComplete(ctx context.Context, resourceGroupName string) (result VirtualNetworkGatewayListResultIterator, err error) { 1252 if tracing.IsEnabled() { 1253 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.List") 1254 defer func() { 1255 sc := -1 1256 if result.Response().Response.Response != nil { 1257 sc = result.page.Response().Response.Response.StatusCode 1258 } 1259 tracing.EndSpan(ctx, sc, err) 1260 }() 1261 } 1262 result.page, err = client.List(ctx, resourceGroupName) 1263 return 1264} 1265 1266// ListConnections gets all the connections in a virtual network gateway. 1267// Parameters: 1268// resourceGroupName - the name of the resource group. 1269// virtualNetworkGatewayName - the name of the virtual network gateway. 1270func (client VirtualNetworkGatewaysClient) ListConnections(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewayListConnectionsResultPage, err error) { 1271 if tracing.IsEnabled() { 1272 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.ListConnections") 1273 defer func() { 1274 sc := -1 1275 if result.vnglcr.Response.Response != nil { 1276 sc = result.vnglcr.Response.Response.StatusCode 1277 } 1278 tracing.EndSpan(ctx, sc, err) 1279 }() 1280 } 1281 result.fn = client.listConnectionsNextResults 1282 req, err := client.ListConnectionsPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 1283 if err != nil { 1284 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", nil, "Failure preparing request") 1285 return 1286 } 1287 1288 resp, err := client.ListConnectionsSender(req) 1289 if err != nil { 1290 result.vnglcr.Response = autorest.Response{Response: resp} 1291 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", resp, "Failure sending request") 1292 return 1293 } 1294 1295 result.vnglcr, err = client.ListConnectionsResponder(resp) 1296 if err != nil { 1297 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ListConnections", resp, "Failure responding to request") 1298 return 1299 } 1300 if result.vnglcr.hasNextLink() && result.vnglcr.IsEmpty() { 1301 err = result.NextWithContext(ctx) 1302 return 1303 } 1304 1305 return 1306} 1307 1308// ListConnectionsPreparer prepares the ListConnections request. 1309func (client VirtualNetworkGatewaysClient) ListConnectionsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 1310 pathParameters := map[string]interface{}{ 1311 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1312 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1313 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1314 } 1315 1316 const APIVersion = "2019-04-01" 1317 queryParameters := map[string]interface{}{ 1318 "api-version": APIVersion, 1319 } 1320 1321 preparer := autorest.CreatePreparer( 1322 autorest.AsGet(), 1323 autorest.WithBaseURL(client.BaseURI), 1324 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/connections", pathParameters), 1325 autorest.WithQueryParameters(queryParameters)) 1326 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1327} 1328 1329// ListConnectionsSender sends the ListConnections request. The method will close the 1330// http.Response Body if it receives an error. 1331func (client VirtualNetworkGatewaysClient) ListConnectionsSender(req *http.Request) (*http.Response, error) { 1332 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1333} 1334 1335// ListConnectionsResponder handles the response to the ListConnections request. The method always 1336// closes the http.Response Body. 1337func (client VirtualNetworkGatewaysClient) ListConnectionsResponder(resp *http.Response) (result VirtualNetworkGatewayListConnectionsResult, err error) { 1338 err = autorest.Respond( 1339 resp, 1340 azure.WithErrorUnlessStatusCode(http.StatusOK), 1341 autorest.ByUnmarshallingJSON(&result), 1342 autorest.ByClosing()) 1343 result.Response = autorest.Response{Response: resp} 1344 return 1345} 1346 1347// listConnectionsNextResults retrieves the next set of results, if any. 1348func (client VirtualNetworkGatewaysClient) listConnectionsNextResults(ctx context.Context, lastResults VirtualNetworkGatewayListConnectionsResult) (result VirtualNetworkGatewayListConnectionsResult, err error) { 1349 req, err := lastResults.virtualNetworkGatewayListConnectionsResultPreparer(ctx) 1350 if err != nil { 1351 return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", nil, "Failure preparing next results request") 1352 } 1353 if req == nil { 1354 return 1355 } 1356 resp, err := client.ListConnectionsSender(req) 1357 if err != nil { 1358 result.Response = autorest.Response{Response: resp} 1359 return result, autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", resp, "Failure sending next results request") 1360 } 1361 result, err = client.ListConnectionsResponder(resp) 1362 if err != nil { 1363 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "listConnectionsNextResults", resp, "Failure responding to next results request") 1364 } 1365 return 1366} 1367 1368// ListConnectionsComplete enumerates all values, automatically crossing page boundaries as required. 1369func (client VirtualNetworkGatewaysClient) ListConnectionsComplete(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewayListConnectionsResultIterator, err error) { 1370 if tracing.IsEnabled() { 1371 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.ListConnections") 1372 defer func() { 1373 sc := -1 1374 if result.Response().Response.Response != nil { 1375 sc = result.page.Response().Response.Response.StatusCode 1376 } 1377 tracing.EndSpan(ctx, sc, err) 1378 }() 1379 } 1380 result.page, err = client.ListConnections(ctx, resourceGroupName, virtualNetworkGatewayName) 1381 return 1382} 1383 1384// Reset resets the primary of the virtual network gateway in the specified resource group. 1385// Parameters: 1386// resourceGroupName - the name of the resource group. 1387// virtualNetworkGatewayName - the name of the virtual network gateway. 1388// gatewayVip - virtual network gateway vip address supplied to the begin reset of the active-active feature 1389// enabled gateway. 1390func (client VirtualNetworkGatewaysClient) Reset(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, gatewayVip string) (result VirtualNetworkGatewaysResetFuture, err error) { 1391 if tracing.IsEnabled() { 1392 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.Reset") 1393 defer func() { 1394 sc := -1 1395 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1396 sc = result.FutureAPI.Response().StatusCode 1397 } 1398 tracing.EndSpan(ctx, sc, err) 1399 }() 1400 } 1401 req, err := client.ResetPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, gatewayVip) 1402 if err != nil { 1403 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Reset", nil, "Failure preparing request") 1404 return 1405 } 1406 1407 result, err = client.ResetSender(req) 1408 if err != nil { 1409 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "Reset", nil, "Failure sending request") 1410 return 1411 } 1412 1413 return 1414} 1415 1416// ResetPreparer prepares the Reset request. 1417func (client VirtualNetworkGatewaysClient) ResetPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, gatewayVip string) (*http.Request, error) { 1418 pathParameters := map[string]interface{}{ 1419 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1420 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1421 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1422 } 1423 1424 const APIVersion = "2019-04-01" 1425 queryParameters := map[string]interface{}{ 1426 "api-version": APIVersion, 1427 } 1428 if len(gatewayVip) > 0 { 1429 queryParameters["gatewayVip"] = autorest.Encode("query", gatewayVip) 1430 } 1431 1432 preparer := autorest.CreatePreparer( 1433 autorest.AsPost(), 1434 autorest.WithBaseURL(client.BaseURI), 1435 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/reset", pathParameters), 1436 autorest.WithQueryParameters(queryParameters)) 1437 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1438} 1439 1440// ResetSender sends the Reset request. The method will close the 1441// http.Response Body if it receives an error. 1442func (client VirtualNetworkGatewaysClient) ResetSender(req *http.Request) (future VirtualNetworkGatewaysResetFuture, err error) { 1443 var resp *http.Response 1444 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1445 if err != nil { 1446 return 1447 } 1448 var azf azure.Future 1449 azf, err = azure.NewFutureFromResponse(resp) 1450 future.FutureAPI = &azf 1451 future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) { 1452 var done bool 1453 done, err = future.DoneWithContext(context.Background(), client) 1454 if err != nil { 1455 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", future.Response(), "Polling failure") 1456 return 1457 } 1458 if !done { 1459 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysResetFuture") 1460 return 1461 } 1462 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1463 vng.Response.Response, err = future.GetResult(sender) 1464 if vng.Response.Response == nil && err == nil { 1465 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", nil, "received nil response and error") 1466 } 1467 if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent { 1468 vng, err = client.ResetResponder(vng.Response.Response) 1469 if err != nil { 1470 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetFuture", "Result", vng.Response.Response, "Failure responding to request") 1471 } 1472 } 1473 return 1474 } 1475 return 1476} 1477 1478// ResetResponder handles the response to the Reset request. The method always 1479// closes the http.Response Body. 1480func (client VirtualNetworkGatewaysClient) ResetResponder(resp *http.Response) (result VirtualNetworkGateway, err error) { 1481 err = autorest.Respond( 1482 resp, 1483 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1484 autorest.ByUnmarshallingJSON(&result), 1485 autorest.ByClosing()) 1486 result.Response = autorest.Response{Response: resp} 1487 return 1488} 1489 1490// ResetVpnClientSharedKey resets the VPN client shared key of the virtual network gateway in the specified resource 1491// group. 1492// Parameters: 1493// resourceGroupName - the name of the resource group. 1494// virtualNetworkGatewayName - the name of the virtual network gateway. 1495func (client VirtualNetworkGatewaysClient) ResetVpnClientSharedKey(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result VirtualNetworkGatewaysResetVpnClientSharedKeyFuture, err error) { 1496 if tracing.IsEnabled() { 1497 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.ResetVpnClientSharedKey") 1498 defer func() { 1499 sc := -1 1500 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1501 sc = result.FutureAPI.Response().StatusCode 1502 } 1503 tracing.EndSpan(ctx, sc, err) 1504 }() 1505 } 1506 req, err := client.ResetVpnClientSharedKeyPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 1507 if err != nil { 1508 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ResetVpnClientSharedKey", nil, "Failure preparing request") 1509 return 1510 } 1511 1512 result, err = client.ResetVpnClientSharedKeySender(req) 1513 if err != nil { 1514 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "ResetVpnClientSharedKey", nil, "Failure sending request") 1515 return 1516 } 1517 1518 return 1519} 1520 1521// ResetVpnClientSharedKeyPreparer prepares the ResetVpnClientSharedKey request. 1522func (client VirtualNetworkGatewaysClient) ResetVpnClientSharedKeyPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 1523 pathParameters := map[string]interface{}{ 1524 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1525 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1526 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1527 } 1528 1529 const APIVersion = "2019-04-01" 1530 queryParameters := map[string]interface{}{ 1531 "api-version": APIVersion, 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}/resetvpnclientsharedkey", pathParameters), 1538 autorest.WithQueryParameters(queryParameters)) 1539 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1540} 1541 1542// ResetVpnClientSharedKeySender sends the ResetVpnClientSharedKey request. The method will close the 1543// http.Response Body if it receives an error. 1544func (client VirtualNetworkGatewaysClient) ResetVpnClientSharedKeySender(req *http.Request) (future VirtualNetworkGatewaysResetVpnClientSharedKeyFuture, 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) (ar autorest.Response, err error) { 1554 var done bool 1555 done, err = future.DoneWithContext(context.Background(), client) 1556 if err != nil { 1557 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysResetVpnClientSharedKeyFuture", "Result", future.Response(), "Polling failure") 1558 return 1559 } 1560 if !done { 1561 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysResetVpnClientSharedKeyFuture") 1562 return 1563 } 1564 ar.Response = future.Response() 1565 return 1566 } 1567 return 1568} 1569 1570// ResetVpnClientSharedKeyResponder handles the response to the ResetVpnClientSharedKey request. The method always 1571// closes the http.Response Body. 1572func (client VirtualNetworkGatewaysClient) ResetVpnClientSharedKeyResponder(resp *http.Response) (result autorest.Response, err error) { 1573 err = autorest.Respond( 1574 resp, 1575 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1576 autorest.ByClosing()) 1577 result.Response = resp 1578 return 1579} 1580 1581// SetVpnclientIpsecParameters the Set VpnclientIpsecParameters operation sets the vpnclient ipsec policy for P2S 1582// client of virtual network gateway in the specified resource group through Network resource provider. 1583// Parameters: 1584// resourceGroupName - the name of the resource group. 1585// virtualNetworkGatewayName - the name of the virtual network gateway. 1586// vpnclientIpsecParams - parameters supplied to the Begin Set vpnclient ipsec parameters of Virtual Network 1587// Gateway P2S client operation through Network resource provider. 1588func (client VirtualNetworkGatewaysClient) SetVpnclientIpsecParameters(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, vpnclientIpsecParams VpnClientIPsecParameters) (result VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture, err error) { 1589 if tracing.IsEnabled() { 1590 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.SetVpnclientIpsecParameters") 1591 defer func() { 1592 sc := -1 1593 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1594 sc = result.FutureAPI.Response().StatusCode 1595 } 1596 tracing.EndSpan(ctx, sc, err) 1597 }() 1598 } 1599 if err := validation.Validate([]validation.Validation{ 1600 {TargetValue: vpnclientIpsecParams, 1601 Constraints: []validation.Constraint{{Target: "vpnclientIpsecParams.SaLifeTimeSeconds", Name: validation.Null, Rule: true, Chain: nil}, 1602 {Target: "vpnclientIpsecParams.SaDataSizeKilobytes", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 1603 return result, validation.NewError("network.VirtualNetworkGatewaysClient", "SetVpnclientIpsecParameters", err.Error()) 1604 } 1605 1606 req, err := client.SetVpnclientIpsecParametersPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, vpnclientIpsecParams) 1607 if err != nil { 1608 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SetVpnclientIpsecParameters", nil, "Failure preparing request") 1609 return 1610 } 1611 1612 result, err = client.SetVpnclientIpsecParametersSender(req) 1613 if err != nil { 1614 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SetVpnclientIpsecParameters", nil, "Failure sending request") 1615 return 1616 } 1617 1618 return 1619} 1620 1621// SetVpnclientIpsecParametersPreparer prepares the SetVpnclientIpsecParameters request. 1622func (client VirtualNetworkGatewaysClient) SetVpnclientIpsecParametersPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, vpnclientIpsecParams VpnClientIPsecParameters) (*http.Request, error) { 1623 pathParameters := map[string]interface{}{ 1624 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1625 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1626 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1627 } 1628 1629 const APIVersion = "2019-04-01" 1630 queryParameters := map[string]interface{}{ 1631 "api-version": APIVersion, 1632 } 1633 1634 preparer := autorest.CreatePreparer( 1635 autorest.AsContentType("application/json; charset=utf-8"), 1636 autorest.AsPost(), 1637 autorest.WithBaseURL(client.BaseURI), 1638 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/setvpnclientipsecparameters", pathParameters), 1639 autorest.WithJSON(vpnclientIpsecParams), 1640 autorest.WithQueryParameters(queryParameters)) 1641 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1642} 1643 1644// SetVpnclientIpsecParametersSender sends the SetVpnclientIpsecParameters request. The method will close the 1645// http.Response Body if it receives an error. 1646func (client VirtualNetworkGatewaysClient) SetVpnclientIpsecParametersSender(req *http.Request) (future VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture, 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) (vcipp VpnClientIPsecParameters, err error) { 1656 var done bool 1657 done, err = future.DoneWithContext(context.Background(), client) 1658 if err != nil { 1659 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture", "Result", future.Response(), "Polling failure") 1660 return 1661 } 1662 if !done { 1663 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture") 1664 return 1665 } 1666 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1667 vcipp.Response.Response, err = future.GetResult(sender) 1668 if vcipp.Response.Response == nil && err == nil { 1669 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture", "Result", nil, "received nil response and error") 1670 } 1671 if err == nil && vcipp.Response.Response.StatusCode != http.StatusNoContent { 1672 vcipp, err = client.SetVpnclientIpsecParametersResponder(vcipp.Response.Response) 1673 if err != nil { 1674 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysSetVpnclientIpsecParametersFuture", "Result", vcipp.Response.Response, "Failure responding to request") 1675 } 1676 } 1677 return 1678 } 1679 return 1680} 1681 1682// SetVpnclientIpsecParametersResponder handles the response to the SetVpnclientIpsecParameters request. The method always 1683// closes the http.Response Body. 1684func (client VirtualNetworkGatewaysClient) SetVpnclientIpsecParametersResponder(resp *http.Response) (result VpnClientIPsecParameters, err error) { 1685 err = autorest.Respond( 1686 resp, 1687 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1688 autorest.ByUnmarshallingJSON(&result), 1689 autorest.ByClosing()) 1690 result.Response = autorest.Response{Response: resp} 1691 return 1692} 1693 1694// SupportedVpnDevices gets a xml format representation for supported vpn devices. 1695// Parameters: 1696// resourceGroupName - the name of the resource group. 1697// virtualNetworkGatewayName - the name of the virtual network gateway. 1698func (client VirtualNetworkGatewaysClient) SupportedVpnDevices(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (result String, err error) { 1699 if tracing.IsEnabled() { 1700 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.SupportedVpnDevices") 1701 defer func() { 1702 sc := -1 1703 if result.Response.Response != nil { 1704 sc = result.Response.Response.StatusCode 1705 } 1706 tracing.EndSpan(ctx, sc, err) 1707 }() 1708 } 1709 req, err := client.SupportedVpnDevicesPreparer(ctx, resourceGroupName, virtualNetworkGatewayName) 1710 if err != nil { 1711 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", nil, "Failure preparing request") 1712 return 1713 } 1714 1715 resp, err := client.SupportedVpnDevicesSender(req) 1716 if err != nil { 1717 result.Response = autorest.Response{Response: resp} 1718 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", resp, "Failure sending request") 1719 return 1720 } 1721 1722 result, err = client.SupportedVpnDevicesResponder(resp) 1723 if err != nil { 1724 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "SupportedVpnDevices", resp, "Failure responding to request") 1725 return 1726 } 1727 1728 return 1729} 1730 1731// SupportedVpnDevicesPreparer prepares the SupportedVpnDevices request. 1732func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string) (*http.Request, error) { 1733 pathParameters := map[string]interface{}{ 1734 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1735 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1736 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1737 } 1738 1739 const APIVersion = "2019-04-01" 1740 queryParameters := map[string]interface{}{ 1741 "api-version": APIVersion, 1742 } 1743 1744 preparer := autorest.CreatePreparer( 1745 autorest.AsPost(), 1746 autorest.WithBaseURL(client.BaseURI), 1747 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/supportedvpndevices", pathParameters), 1748 autorest.WithQueryParameters(queryParameters)) 1749 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1750} 1751 1752// SupportedVpnDevicesSender sends the SupportedVpnDevices request. The method will close the 1753// http.Response Body if it receives an error. 1754func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesSender(req *http.Request) (*http.Response, error) { 1755 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1756} 1757 1758// SupportedVpnDevicesResponder handles the response to the SupportedVpnDevices request. The method always 1759// closes the http.Response Body. 1760func (client VirtualNetworkGatewaysClient) SupportedVpnDevicesResponder(resp *http.Response) (result String, err error) { 1761 err = autorest.Respond( 1762 resp, 1763 azure.WithErrorUnlessStatusCode(http.StatusOK), 1764 autorest.ByUnmarshallingJSON(&result.Value), 1765 autorest.ByClosing()) 1766 result.Response = autorest.Response{Response: resp} 1767 return 1768} 1769 1770// UpdateTags updates a virtual network gateway tags. 1771// Parameters: 1772// resourceGroupName - the name of the resource group. 1773// virtualNetworkGatewayName - the name of the virtual network gateway. 1774// parameters - parameters supplied to update virtual network gateway tags. 1775func (client VirtualNetworkGatewaysClient) UpdateTags(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject) (result VirtualNetworkGatewaysUpdateTagsFuture, err error) { 1776 if tracing.IsEnabled() { 1777 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.UpdateTags") 1778 defer func() { 1779 sc := -1 1780 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 1781 sc = result.FutureAPI.Response().StatusCode 1782 } 1783 tracing.EndSpan(ctx, sc, err) 1784 }() 1785 } 1786 req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, virtualNetworkGatewayName, parameters) 1787 if err != nil { 1788 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "UpdateTags", nil, "Failure preparing request") 1789 return 1790 } 1791 1792 result, err = client.UpdateTagsSender(req) 1793 if err != nil { 1794 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "UpdateTags", nil, "Failure sending request") 1795 return 1796 } 1797 1798 return 1799} 1800 1801// UpdateTagsPreparer prepares the UpdateTags request. 1802func (client VirtualNetworkGatewaysClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject) (*http.Request, error) { 1803 pathParameters := map[string]interface{}{ 1804 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1805 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1806 "virtualNetworkGatewayName": autorest.Encode("path", virtualNetworkGatewayName), 1807 } 1808 1809 const APIVersion = "2019-04-01" 1810 queryParameters := map[string]interface{}{ 1811 "api-version": APIVersion, 1812 } 1813 1814 preparer := autorest.CreatePreparer( 1815 autorest.AsContentType("application/json; charset=utf-8"), 1816 autorest.AsPatch(), 1817 autorest.WithBaseURL(client.BaseURI), 1818 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}", pathParameters), 1819 autorest.WithJSON(parameters), 1820 autorest.WithQueryParameters(queryParameters)) 1821 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1822} 1823 1824// UpdateTagsSender sends the UpdateTags request. The method will close the 1825// http.Response Body if it receives an error. 1826func (client VirtualNetworkGatewaysClient) UpdateTagsSender(req *http.Request) (future VirtualNetworkGatewaysUpdateTagsFuture, err error) { 1827 var resp *http.Response 1828 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1829 if err != nil { 1830 return 1831 } 1832 var azf azure.Future 1833 azf, err = azure.NewFutureFromResponse(resp) 1834 future.FutureAPI = &azf 1835 future.Result = func(client VirtualNetworkGatewaysClient) (vng VirtualNetworkGateway, err error) { 1836 var done bool 1837 done, err = future.DoneWithContext(context.Background(), client) 1838 if err != nil { 1839 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", future.Response(), "Polling failure") 1840 return 1841 } 1842 if !done { 1843 err = azure.NewAsyncOpIncompleteError("network.VirtualNetworkGatewaysUpdateTagsFuture") 1844 return 1845 } 1846 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1847 vng.Response.Response, err = future.GetResult(sender) 1848 if vng.Response.Response == nil && err == nil { 1849 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", nil, "received nil response and error") 1850 } 1851 if err == nil && vng.Response.Response.StatusCode != http.StatusNoContent { 1852 vng, err = client.UpdateTagsResponder(vng.Response.Response) 1853 if err != nil { 1854 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysUpdateTagsFuture", "Result", vng.Response.Response, "Failure responding to request") 1855 } 1856 } 1857 return 1858 } 1859 return 1860} 1861 1862// UpdateTagsResponder handles the response to the UpdateTags request. The method always 1863// closes the http.Response Body. 1864func (client VirtualNetworkGatewaysClient) UpdateTagsResponder(resp *http.Response) (result VirtualNetworkGateway, err error) { 1865 err = autorest.Respond( 1866 resp, 1867 azure.WithErrorUnlessStatusCode(http.StatusOK), 1868 autorest.ByUnmarshallingJSON(&result), 1869 autorest.ByClosing()) 1870 result.Response = autorest.Response{Response: resp} 1871 return 1872} 1873 1874// VpnDeviceConfigurationScript gets a xml format representation for vpn device configuration script. 1875// Parameters: 1876// resourceGroupName - the name of the resource group. 1877// virtualNetworkGatewayConnectionName - the name of the virtual network gateway connection for which the 1878// configuration script is generated. 1879// parameters - parameters supplied to the generate vpn device script operation. 1880func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScript(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VpnDeviceScriptParameters) (result String, err error) { 1881 if tracing.IsEnabled() { 1882 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualNetworkGatewaysClient.VpnDeviceConfigurationScript") 1883 defer func() { 1884 sc := -1 1885 if result.Response.Response != nil { 1886 sc = result.Response.Response.StatusCode 1887 } 1888 tracing.EndSpan(ctx, sc, err) 1889 }() 1890 } 1891 req, err := client.VpnDeviceConfigurationScriptPreparer(ctx, resourceGroupName, virtualNetworkGatewayConnectionName, parameters) 1892 if err != nil { 1893 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", nil, "Failure preparing request") 1894 return 1895 } 1896 1897 resp, err := client.VpnDeviceConfigurationScriptSender(req) 1898 if err != nil { 1899 result.Response = autorest.Response{Response: resp} 1900 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", resp, "Failure sending request") 1901 return 1902 } 1903 1904 result, err = client.VpnDeviceConfigurationScriptResponder(resp) 1905 if err != nil { 1906 err = autorest.NewErrorWithError(err, "network.VirtualNetworkGatewaysClient", "VpnDeviceConfigurationScript", resp, "Failure responding to request") 1907 return 1908 } 1909 1910 return 1911} 1912 1913// VpnDeviceConfigurationScriptPreparer prepares the VpnDeviceConfigurationScript request. 1914func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptPreparer(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VpnDeviceScriptParameters) (*http.Request, error) { 1915 pathParameters := map[string]interface{}{ 1916 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1917 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1918 "virtualNetworkGatewayConnectionName": autorest.Encode("path", virtualNetworkGatewayConnectionName), 1919 } 1920 1921 const APIVersion = "2019-04-01" 1922 queryParameters := map[string]interface{}{ 1923 "api-version": APIVersion, 1924 } 1925 1926 preparer := autorest.CreatePreparer( 1927 autorest.AsContentType("application/json; charset=utf-8"), 1928 autorest.AsPost(), 1929 autorest.WithBaseURL(client.BaseURI), 1930 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}/vpndeviceconfigurationscript", pathParameters), 1931 autorest.WithJSON(parameters), 1932 autorest.WithQueryParameters(queryParameters)) 1933 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1934} 1935 1936// VpnDeviceConfigurationScriptSender sends the VpnDeviceConfigurationScript request. The method will close the 1937// http.Response Body if it receives an error. 1938func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptSender(req *http.Request) (*http.Response, error) { 1939 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1940} 1941 1942// VpnDeviceConfigurationScriptResponder handles the response to the VpnDeviceConfigurationScript request. The method always 1943// closes the http.Response Body. 1944func (client VirtualNetworkGatewaysClient) VpnDeviceConfigurationScriptResponder(resp *http.Response) (result String, err error) { 1945 err = autorest.Respond( 1946 resp, 1947 azure.WithErrorUnlessStatusCode(http.StatusOK), 1948 autorest.ByUnmarshallingJSON(&result.Value), 1949 autorest.ByClosing()) 1950 result.Response = autorest.Response{Response: resp} 1951 return 1952} 1953