1// +build go1.13 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// Code generated by Microsoft (R) AutoRest Code Generator. 6// Changes may cause incorrect behavior and will be lost if the code is regenerated. 7 8package armnetwork 9 10import ( 11 "context" 12 "errors" 13 "fmt" 14 "github.com/Azure/azure-sdk-for-go/sdk/armcore" 15 "github.com/Azure/azure-sdk-for-go/sdk/azcore" 16 "net/http" 17 "net/url" 18 "strings" 19 "time" 20) 21 22// VirtualNetworkGatewaysClient contains the methods for the VirtualNetworkGateways group. 23// Don't use this type directly, use NewVirtualNetworkGatewaysClient() instead. 24type VirtualNetworkGatewaysClient struct { 25 con *armcore.Connection 26 subscriptionID string 27} 28 29// NewVirtualNetworkGatewaysClient creates a new instance of VirtualNetworkGatewaysClient with the specified values. 30func NewVirtualNetworkGatewaysClient(con *armcore.Connection, subscriptionID string) *VirtualNetworkGatewaysClient { 31 return &VirtualNetworkGatewaysClient{con: con, subscriptionID: subscriptionID} 32} 33 34// BeginCreateOrUpdate - Creates or updates a virtual network gateway in the specified resource group. 35// If the operation fails it returns the *CloudError error type. 36func (client *VirtualNetworkGatewaysClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VirtualNetworkGateway, options *VirtualNetworkGatewaysBeginCreateOrUpdateOptions) (VirtualNetworkGatewayPollerResponse, error) { 37 resp, err := client.createOrUpdate(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 38 if err != nil { 39 return VirtualNetworkGatewayPollerResponse{}, err 40 } 41 result := VirtualNetworkGatewayPollerResponse{ 42 RawResponse: resp.Response, 43 } 44 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.CreateOrUpdate", "azure-async-operation", resp, client.con.Pipeline(), client.createOrUpdateHandleError) 45 if err != nil { 46 return VirtualNetworkGatewayPollerResponse{}, err 47 } 48 poller := &virtualNetworkGatewayPoller{ 49 pt: pt, 50 } 51 result.Poller = poller 52 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VirtualNetworkGatewayResponse, error) { 53 return poller.pollUntilDone(ctx, frequency) 54 } 55 return result, nil 56} 57 58// ResumeCreateOrUpdate creates a new VirtualNetworkGatewayPoller from the specified resume token. 59// token - The value must come from a previous call to VirtualNetworkGatewayPoller.ResumeToken(). 60func (client *VirtualNetworkGatewaysClient) ResumeCreateOrUpdate(ctx context.Context, token string) (VirtualNetworkGatewayPollerResponse, error) { 61 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError) 62 if err != nil { 63 return VirtualNetworkGatewayPollerResponse{}, err 64 } 65 poller := &virtualNetworkGatewayPoller{ 66 pt: pt, 67 } 68 resp, err := poller.Poll(ctx) 69 if err != nil { 70 return VirtualNetworkGatewayPollerResponse{}, err 71 } 72 result := VirtualNetworkGatewayPollerResponse{ 73 RawResponse: resp, 74 } 75 result.Poller = poller 76 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VirtualNetworkGatewayResponse, error) { 77 return poller.pollUntilDone(ctx, frequency) 78 } 79 return result, nil 80} 81 82// CreateOrUpdate - Creates or updates a virtual network gateway in the specified resource group. 83// If the operation fails it returns the *CloudError error type. 84func (client *VirtualNetworkGatewaysClient) createOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VirtualNetworkGateway, options *VirtualNetworkGatewaysBeginCreateOrUpdateOptions) (*azcore.Response, error) { 85 req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 86 if err != nil { 87 return nil, err 88 } 89 resp, err := client.con.Pipeline().Do(req) 90 if err != nil { 91 return nil, err 92 } 93 if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) { 94 return nil, client.createOrUpdateHandleError(resp) 95 } 96 return resp, nil 97} 98 99// createOrUpdateCreateRequest creates the CreateOrUpdate request. 100func (client *VirtualNetworkGatewaysClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VirtualNetworkGateway, options *VirtualNetworkGatewaysBeginCreateOrUpdateOptions) (*azcore.Request, error) { 101 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}" 102 if resourceGroupName == "" { 103 return nil, errors.New("parameter resourceGroupName cannot be empty") 104 } 105 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 106 if virtualNetworkGatewayName == "" { 107 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 108 } 109 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 110 if client.subscriptionID == "" { 111 return nil, errors.New("parameter client.subscriptionID cannot be empty") 112 } 113 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 114 req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 115 if err != nil { 116 return nil, err 117 } 118 req.Telemetry(telemetryInfo) 119 reqQP := req.URL.Query() 120 reqQP.Set("api-version", "2021-02-01") 121 req.URL.RawQuery = reqQP.Encode() 122 req.Header.Set("Accept", "application/json") 123 return req, req.MarshalAsJSON(parameters) 124} 125 126// createOrUpdateHandleError handles the CreateOrUpdate error response. 127func (client *VirtualNetworkGatewaysClient) createOrUpdateHandleError(resp *azcore.Response) error { 128 body, err := resp.Payload() 129 if err != nil { 130 return azcore.NewResponseError(err, resp.Response) 131 } 132 errType := CloudError{raw: string(body)} 133 if err := resp.UnmarshalAsJSON(&errType); err != nil { 134 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 135 } 136 return azcore.NewResponseError(&errType, resp.Response) 137} 138 139// BeginDelete - Deletes the specified virtual network gateway. 140// If the operation fails it returns the *CloudError error type. 141func (client *VirtualNetworkGatewaysClient) BeginDelete(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginDeleteOptions) (HTTPPollerResponse, error) { 142 resp, err := client.deleteOperation(ctx, resourceGroupName, virtualNetworkGatewayName, options) 143 if err != nil { 144 return HTTPPollerResponse{}, err 145 } 146 result := HTTPPollerResponse{ 147 RawResponse: resp.Response, 148 } 149 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.Delete", "location", resp, client.con.Pipeline(), client.deleteHandleError) 150 if err != nil { 151 return HTTPPollerResponse{}, err 152 } 153 poller := &httpPoller{ 154 pt: pt, 155 } 156 result.Poller = poller 157 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) { 158 return poller.pollUntilDone(ctx, frequency) 159 } 160 return result, nil 161} 162 163// ResumeDelete creates a new HTTPPoller from the specified resume token. 164// token - The value must come from a previous call to HTTPPoller.ResumeToken(). 165func (client *VirtualNetworkGatewaysClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) { 166 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.Delete", token, client.con.Pipeline(), client.deleteHandleError) 167 if err != nil { 168 return HTTPPollerResponse{}, err 169 } 170 poller := &httpPoller{ 171 pt: pt, 172 } 173 resp, err := poller.Poll(ctx) 174 if err != nil { 175 return HTTPPollerResponse{}, err 176 } 177 result := HTTPPollerResponse{ 178 RawResponse: resp, 179 } 180 result.Poller = poller 181 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) { 182 return poller.pollUntilDone(ctx, frequency) 183 } 184 return result, nil 185} 186 187// Delete - Deletes the specified virtual network gateway. 188// If the operation fails it returns the *CloudError error type. 189func (client *VirtualNetworkGatewaysClient) deleteOperation(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginDeleteOptions) (*azcore.Response, error) { 190 req, err := client.deleteCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 191 if err != nil { 192 return nil, err 193 } 194 resp, err := client.con.Pipeline().Do(req) 195 if err != nil { 196 return nil, err 197 } 198 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) { 199 return nil, client.deleteHandleError(resp) 200 } 201 return resp, nil 202} 203 204// deleteCreateRequest creates the Delete request. 205func (client *VirtualNetworkGatewaysClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginDeleteOptions) (*azcore.Request, error) { 206 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}" 207 if resourceGroupName == "" { 208 return nil, errors.New("parameter resourceGroupName cannot be empty") 209 } 210 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 211 if virtualNetworkGatewayName == "" { 212 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 213 } 214 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 215 if client.subscriptionID == "" { 216 return nil, errors.New("parameter client.subscriptionID cannot be empty") 217 } 218 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 219 req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 220 if err != nil { 221 return nil, err 222 } 223 req.Telemetry(telemetryInfo) 224 reqQP := req.URL.Query() 225 reqQP.Set("api-version", "2021-02-01") 226 req.URL.RawQuery = reqQP.Encode() 227 req.Header.Set("Accept", "application/json") 228 return req, nil 229} 230 231// deleteHandleError handles the Delete error response. 232func (client *VirtualNetworkGatewaysClient) deleteHandleError(resp *azcore.Response) error { 233 body, err := resp.Payload() 234 if err != nil { 235 return azcore.NewResponseError(err, resp.Response) 236 } 237 errType := CloudError{raw: string(body)} 238 if err := resp.UnmarshalAsJSON(&errType); err != nil { 239 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 240 } 241 return azcore.NewResponseError(&errType, resp.Response) 242} 243 244// BeginDisconnectVirtualNetworkGatewayVPNConnections - Disconnect vpn connections of virtual network gateway in the specified resource group. 245// If the operation fails it returns the *CloudError error type. 246func (client *VirtualNetworkGatewaysClient) BeginDisconnectVirtualNetworkGatewayVPNConnections(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, request P2SVPNConnectionRequest, options *VirtualNetworkGatewaysBeginDisconnectVirtualNetworkGatewayVPNConnectionsOptions) (HTTPPollerResponse, error) { 247 resp, err := client.disconnectVirtualNetworkGatewayVPNConnections(ctx, resourceGroupName, virtualNetworkGatewayName, request, options) 248 if err != nil { 249 return HTTPPollerResponse{}, err 250 } 251 result := HTTPPollerResponse{ 252 RawResponse: resp.Response, 253 } 254 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.DisconnectVirtualNetworkGatewayVPNConnections", "location", resp, client.con.Pipeline(), client.disconnectVirtualNetworkGatewayVPNConnectionsHandleError) 255 if err != nil { 256 return HTTPPollerResponse{}, err 257 } 258 poller := &httpPoller{ 259 pt: pt, 260 } 261 result.Poller = poller 262 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) { 263 return poller.pollUntilDone(ctx, frequency) 264 } 265 return result, nil 266} 267 268// ResumeDisconnectVirtualNetworkGatewayVPNConnections creates a new HTTPPoller from the specified resume token. 269// token - The value must come from a previous call to HTTPPoller.ResumeToken(). 270func (client *VirtualNetworkGatewaysClient) ResumeDisconnectVirtualNetworkGatewayVPNConnections(ctx context.Context, token string) (HTTPPollerResponse, error) { 271 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.DisconnectVirtualNetworkGatewayVPNConnections", token, client.con.Pipeline(), client.disconnectVirtualNetworkGatewayVPNConnectionsHandleError) 272 if err != nil { 273 return HTTPPollerResponse{}, err 274 } 275 poller := &httpPoller{ 276 pt: pt, 277 } 278 resp, err := poller.Poll(ctx) 279 if err != nil { 280 return HTTPPollerResponse{}, err 281 } 282 result := HTTPPollerResponse{ 283 RawResponse: resp, 284 } 285 result.Poller = poller 286 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) { 287 return poller.pollUntilDone(ctx, frequency) 288 } 289 return result, nil 290} 291 292// DisconnectVirtualNetworkGatewayVPNConnections - Disconnect vpn connections of virtual network gateway in the specified resource group. 293// If the operation fails it returns the *CloudError error type. 294func (client *VirtualNetworkGatewaysClient) disconnectVirtualNetworkGatewayVPNConnections(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, request P2SVPNConnectionRequest, options *VirtualNetworkGatewaysBeginDisconnectVirtualNetworkGatewayVPNConnectionsOptions) (*azcore.Response, error) { 295 req, err := client.disconnectVirtualNetworkGatewayVPNConnectionsCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, request, options) 296 if err != nil { 297 return nil, err 298 } 299 resp, err := client.con.Pipeline().Do(req) 300 if err != nil { 301 return nil, err 302 } 303 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 304 return nil, client.disconnectVirtualNetworkGatewayVPNConnectionsHandleError(resp) 305 } 306 return resp, nil 307} 308 309// disconnectVirtualNetworkGatewayVPNConnectionsCreateRequest creates the DisconnectVirtualNetworkGatewayVPNConnections request. 310func (client *VirtualNetworkGatewaysClient) disconnectVirtualNetworkGatewayVPNConnectionsCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, request P2SVPNConnectionRequest, options *VirtualNetworkGatewaysBeginDisconnectVirtualNetworkGatewayVPNConnectionsOptions) (*azcore.Request, error) { 311 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/disconnectVirtualNetworkGatewayVpnConnections" 312 if client.subscriptionID == "" { 313 return nil, errors.New("parameter client.subscriptionID cannot be empty") 314 } 315 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 316 if resourceGroupName == "" { 317 return nil, errors.New("parameter resourceGroupName cannot be empty") 318 } 319 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 320 if virtualNetworkGatewayName == "" { 321 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 322 } 323 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 324 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 325 if err != nil { 326 return nil, err 327 } 328 req.Telemetry(telemetryInfo) 329 reqQP := req.URL.Query() 330 reqQP.Set("api-version", "2021-02-01") 331 req.URL.RawQuery = reqQP.Encode() 332 req.Header.Set("Accept", "application/json") 333 return req, req.MarshalAsJSON(request) 334} 335 336// disconnectVirtualNetworkGatewayVPNConnectionsHandleError handles the DisconnectVirtualNetworkGatewayVPNConnections error response. 337func (client *VirtualNetworkGatewaysClient) disconnectVirtualNetworkGatewayVPNConnectionsHandleError(resp *azcore.Response) error { 338 body, err := resp.Payload() 339 if err != nil { 340 return azcore.NewResponseError(err, resp.Response) 341 } 342 errType := CloudError{raw: string(body)} 343 if err := resp.UnmarshalAsJSON(&errType); err != nil { 344 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 345 } 346 return azcore.NewResponseError(&errType, resp.Response) 347} 348 349// BeginGenerateVPNProfile - Generates VPN profile for P2S client of the virtual network gateway in the specified resource group. Used for IKEV2 and radius 350// based authentication. 351// If the operation fails it returns the *CloudError error type. 352func (client *VirtualNetworkGatewaysClient) BeginGenerateVPNProfile(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNClientParameters, options *VirtualNetworkGatewaysBeginGenerateVPNProfileOptions) (StringPollerResponse, error) { 353 resp, err := client.generateVPNProfile(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 354 if err != nil { 355 return StringPollerResponse{}, err 356 } 357 result := StringPollerResponse{ 358 RawResponse: resp.Response, 359 } 360 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.GenerateVPNProfile", "location", resp, client.con.Pipeline(), client.generateVPNProfileHandleError) 361 if err != nil { 362 return StringPollerResponse{}, err 363 } 364 poller := &stringPoller{ 365 pt: pt, 366 } 367 result.Poller = poller 368 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 369 return poller.pollUntilDone(ctx, frequency) 370 } 371 return result, nil 372} 373 374// ResumeGenerateVPNProfile creates a new StringPoller from the specified resume token. 375// token - The value must come from a previous call to StringPoller.ResumeToken(). 376func (client *VirtualNetworkGatewaysClient) ResumeGenerateVPNProfile(ctx context.Context, token string) (StringPollerResponse, error) { 377 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.GenerateVPNProfile", token, client.con.Pipeline(), client.generateVPNProfileHandleError) 378 if err != nil { 379 return StringPollerResponse{}, err 380 } 381 poller := &stringPoller{ 382 pt: pt, 383 } 384 resp, err := poller.Poll(ctx) 385 if err != nil { 386 return StringPollerResponse{}, err 387 } 388 result := StringPollerResponse{ 389 RawResponse: resp, 390 } 391 result.Poller = poller 392 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 393 return poller.pollUntilDone(ctx, frequency) 394 } 395 return result, nil 396} 397 398// GenerateVPNProfile - Generates VPN profile for P2S client of the virtual network gateway in the specified resource group. Used for IKEV2 and radius based 399// authentication. 400// If the operation fails it returns the *CloudError error type. 401func (client *VirtualNetworkGatewaysClient) generateVPNProfile(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNClientParameters, options *VirtualNetworkGatewaysBeginGenerateVPNProfileOptions) (*azcore.Response, error) { 402 req, err := client.generateVPNProfileCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 403 if err != nil { 404 return nil, err 405 } 406 resp, err := client.con.Pipeline().Do(req) 407 if err != nil { 408 return nil, err 409 } 410 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 411 return nil, client.generateVPNProfileHandleError(resp) 412 } 413 return resp, nil 414} 415 416// generateVPNProfileCreateRequest creates the GenerateVPNProfile request. 417func (client *VirtualNetworkGatewaysClient) generateVPNProfileCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNClientParameters, options *VirtualNetworkGatewaysBeginGenerateVPNProfileOptions) (*azcore.Request, error) { 418 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnprofile" 419 if resourceGroupName == "" { 420 return nil, errors.New("parameter resourceGroupName cannot be empty") 421 } 422 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 423 if virtualNetworkGatewayName == "" { 424 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 425 } 426 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 427 if client.subscriptionID == "" { 428 return nil, errors.New("parameter client.subscriptionID cannot be empty") 429 } 430 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 431 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 432 if err != nil { 433 return nil, err 434 } 435 req.Telemetry(telemetryInfo) 436 reqQP := req.URL.Query() 437 reqQP.Set("api-version", "2021-02-01") 438 req.URL.RawQuery = reqQP.Encode() 439 req.Header.Set("Accept", "application/json") 440 return req, req.MarshalAsJSON(parameters) 441} 442 443// generateVPNProfileHandleError handles the GenerateVPNProfile error response. 444func (client *VirtualNetworkGatewaysClient) generateVPNProfileHandleError(resp *azcore.Response) error { 445 body, err := resp.Payload() 446 if err != nil { 447 return azcore.NewResponseError(err, resp.Response) 448 } 449 errType := CloudError{raw: string(body)} 450 if err := resp.UnmarshalAsJSON(&errType); err != nil { 451 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 452 } 453 return azcore.NewResponseError(&errType, resp.Response) 454} 455 456// BeginGeneratevpnclientpackage - Generates VPN client package for P2S client of the virtual network gateway in the specified resource group. 457// If the operation fails it returns the *CloudError error type. 458func (client *VirtualNetworkGatewaysClient) BeginGeneratevpnclientpackage(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNClientParameters, options *VirtualNetworkGatewaysBeginGeneratevpnclientpackageOptions) (StringPollerResponse, error) { 459 resp, err := client.generatevpnclientpackage(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 460 if err != nil { 461 return StringPollerResponse{}, err 462 } 463 result := StringPollerResponse{ 464 RawResponse: resp.Response, 465 } 466 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.Generatevpnclientpackage", "location", resp, client.con.Pipeline(), client.generatevpnclientpackageHandleError) 467 if err != nil { 468 return StringPollerResponse{}, err 469 } 470 poller := &stringPoller{ 471 pt: pt, 472 } 473 result.Poller = poller 474 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 475 return poller.pollUntilDone(ctx, frequency) 476 } 477 return result, nil 478} 479 480// ResumeGeneratevpnclientpackage creates a new StringPoller from the specified resume token. 481// token - The value must come from a previous call to StringPoller.ResumeToken(). 482func (client *VirtualNetworkGatewaysClient) ResumeGeneratevpnclientpackage(ctx context.Context, token string) (StringPollerResponse, error) { 483 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.Generatevpnclientpackage", token, client.con.Pipeline(), client.generatevpnclientpackageHandleError) 484 if err != nil { 485 return StringPollerResponse{}, err 486 } 487 poller := &stringPoller{ 488 pt: pt, 489 } 490 resp, err := poller.Poll(ctx) 491 if err != nil { 492 return StringPollerResponse{}, err 493 } 494 result := StringPollerResponse{ 495 RawResponse: resp, 496 } 497 result.Poller = poller 498 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 499 return poller.pollUntilDone(ctx, frequency) 500 } 501 return result, nil 502} 503 504// Generatevpnclientpackage - Generates VPN client package for P2S client of the virtual network gateway in the specified resource group. 505// If the operation fails it returns the *CloudError error type. 506func (client *VirtualNetworkGatewaysClient) generatevpnclientpackage(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNClientParameters, options *VirtualNetworkGatewaysBeginGeneratevpnclientpackageOptions) (*azcore.Response, error) { 507 req, err := client.generatevpnclientpackageCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 508 if err != nil { 509 return nil, err 510 } 511 resp, err := client.con.Pipeline().Do(req) 512 if err != nil { 513 return nil, err 514 } 515 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 516 return nil, client.generatevpnclientpackageHandleError(resp) 517 } 518 return resp, nil 519} 520 521// generatevpnclientpackageCreateRequest creates the Generatevpnclientpackage request. 522func (client *VirtualNetworkGatewaysClient) generatevpnclientpackageCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNClientParameters, options *VirtualNetworkGatewaysBeginGeneratevpnclientpackageOptions) (*azcore.Request, error) { 523 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/generatevpnclientpackage" 524 if resourceGroupName == "" { 525 return nil, errors.New("parameter resourceGroupName cannot be empty") 526 } 527 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 528 if virtualNetworkGatewayName == "" { 529 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 530 } 531 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 532 if client.subscriptionID == "" { 533 return nil, errors.New("parameter client.subscriptionID cannot be empty") 534 } 535 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 536 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 537 if err != nil { 538 return nil, err 539 } 540 req.Telemetry(telemetryInfo) 541 reqQP := req.URL.Query() 542 reqQP.Set("api-version", "2021-02-01") 543 req.URL.RawQuery = reqQP.Encode() 544 req.Header.Set("Accept", "application/json") 545 return req, req.MarshalAsJSON(parameters) 546} 547 548// generatevpnclientpackageHandleError handles the Generatevpnclientpackage error response. 549func (client *VirtualNetworkGatewaysClient) generatevpnclientpackageHandleError(resp *azcore.Response) error { 550 body, err := resp.Payload() 551 if err != nil { 552 return azcore.NewResponseError(err, resp.Response) 553 } 554 errType := CloudError{raw: string(body)} 555 if err := resp.UnmarshalAsJSON(&errType); err != nil { 556 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 557 } 558 return azcore.NewResponseError(&errType, resp.Response) 559} 560 561// Get - Gets the specified virtual network gateway by resource group. 562// If the operation fails it returns the *CloudError error type. 563func (client *VirtualNetworkGatewaysClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysGetOptions) (VirtualNetworkGatewayResponse, error) { 564 req, err := client.getCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 565 if err != nil { 566 return VirtualNetworkGatewayResponse{}, err 567 } 568 resp, err := client.con.Pipeline().Do(req) 569 if err != nil { 570 return VirtualNetworkGatewayResponse{}, err 571 } 572 if !resp.HasStatusCode(http.StatusOK) { 573 return VirtualNetworkGatewayResponse{}, client.getHandleError(resp) 574 } 575 return client.getHandleResponse(resp) 576} 577 578// getCreateRequest creates the Get request. 579func (client *VirtualNetworkGatewaysClient) getCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysGetOptions) (*azcore.Request, error) { 580 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}" 581 if resourceGroupName == "" { 582 return nil, errors.New("parameter resourceGroupName cannot be empty") 583 } 584 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 585 if virtualNetworkGatewayName == "" { 586 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 587 } 588 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 589 if client.subscriptionID == "" { 590 return nil, errors.New("parameter client.subscriptionID cannot be empty") 591 } 592 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 593 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 594 if err != nil { 595 return nil, err 596 } 597 req.Telemetry(telemetryInfo) 598 reqQP := req.URL.Query() 599 reqQP.Set("api-version", "2021-02-01") 600 req.URL.RawQuery = reqQP.Encode() 601 req.Header.Set("Accept", "application/json") 602 return req, nil 603} 604 605// getHandleResponse handles the Get response. 606func (client *VirtualNetworkGatewaysClient) getHandleResponse(resp *azcore.Response) (VirtualNetworkGatewayResponse, error) { 607 var val *VirtualNetworkGateway 608 if err := resp.UnmarshalAsJSON(&val); err != nil { 609 return VirtualNetworkGatewayResponse{}, err 610 } 611 return VirtualNetworkGatewayResponse{RawResponse: resp.Response, VirtualNetworkGateway: val}, nil 612} 613 614// getHandleError handles the Get error response. 615func (client *VirtualNetworkGatewaysClient) getHandleError(resp *azcore.Response) error { 616 body, err := resp.Payload() 617 if err != nil { 618 return azcore.NewResponseError(err, resp.Response) 619 } 620 errType := CloudError{raw: string(body)} 621 if err := resp.UnmarshalAsJSON(&errType); err != nil { 622 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 623 } 624 return azcore.NewResponseError(&errType, resp.Response) 625} 626 627// BeginGetAdvertisedRoutes - This operation retrieves a list of routes the virtual network gateway is advertising to the specified peer. 628// If the operation fails it returns the *CloudError error type. 629func (client *VirtualNetworkGatewaysClient) BeginGetAdvertisedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string, options *VirtualNetworkGatewaysBeginGetAdvertisedRoutesOptions) (GatewayRouteListResultPollerResponse, error) { 630 resp, err := client.getAdvertisedRoutes(ctx, resourceGroupName, virtualNetworkGatewayName, peer, options) 631 if err != nil { 632 return GatewayRouteListResultPollerResponse{}, err 633 } 634 result := GatewayRouteListResultPollerResponse{ 635 RawResponse: resp.Response, 636 } 637 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.GetAdvertisedRoutes", "location", resp, client.con.Pipeline(), client.getAdvertisedRoutesHandleError) 638 if err != nil { 639 return GatewayRouteListResultPollerResponse{}, err 640 } 641 poller := &gatewayRouteListResultPoller{ 642 pt: pt, 643 } 644 result.Poller = poller 645 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (GatewayRouteListResultResponse, error) { 646 return poller.pollUntilDone(ctx, frequency) 647 } 648 return result, nil 649} 650 651// ResumeGetAdvertisedRoutes creates a new GatewayRouteListResultPoller from the specified resume token. 652// token - The value must come from a previous call to GatewayRouteListResultPoller.ResumeToken(). 653func (client *VirtualNetworkGatewaysClient) ResumeGetAdvertisedRoutes(ctx context.Context, token string) (GatewayRouteListResultPollerResponse, error) { 654 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.GetAdvertisedRoutes", token, client.con.Pipeline(), client.getAdvertisedRoutesHandleError) 655 if err != nil { 656 return GatewayRouteListResultPollerResponse{}, err 657 } 658 poller := &gatewayRouteListResultPoller{ 659 pt: pt, 660 } 661 resp, err := poller.Poll(ctx) 662 if err != nil { 663 return GatewayRouteListResultPollerResponse{}, err 664 } 665 result := GatewayRouteListResultPollerResponse{ 666 RawResponse: resp, 667 } 668 result.Poller = poller 669 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (GatewayRouteListResultResponse, error) { 670 return poller.pollUntilDone(ctx, frequency) 671 } 672 return result, nil 673} 674 675// GetAdvertisedRoutes - This operation retrieves a list of routes the virtual network gateway is advertising to the specified peer. 676// If the operation fails it returns the *CloudError error type. 677func (client *VirtualNetworkGatewaysClient) getAdvertisedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string, options *VirtualNetworkGatewaysBeginGetAdvertisedRoutesOptions) (*azcore.Response, error) { 678 req, err := client.getAdvertisedRoutesCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, peer, options) 679 if err != nil { 680 return nil, err 681 } 682 resp, err := client.con.Pipeline().Do(req) 683 if err != nil { 684 return nil, err 685 } 686 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 687 return nil, client.getAdvertisedRoutesHandleError(resp) 688 } 689 return resp, nil 690} 691 692// getAdvertisedRoutesCreateRequest creates the GetAdvertisedRoutes request. 693func (client *VirtualNetworkGatewaysClient) getAdvertisedRoutesCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, peer string, options *VirtualNetworkGatewaysBeginGetAdvertisedRoutesOptions) (*azcore.Request, error) { 694 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getAdvertisedRoutes" 695 if resourceGroupName == "" { 696 return nil, errors.New("parameter resourceGroupName cannot be empty") 697 } 698 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 699 if virtualNetworkGatewayName == "" { 700 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 701 } 702 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 703 if client.subscriptionID == "" { 704 return nil, errors.New("parameter client.subscriptionID cannot be empty") 705 } 706 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 707 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 708 if err != nil { 709 return nil, err 710 } 711 req.Telemetry(telemetryInfo) 712 reqQP := req.URL.Query() 713 reqQP.Set("peer", peer) 714 reqQP.Set("api-version", "2021-02-01") 715 req.URL.RawQuery = reqQP.Encode() 716 req.Header.Set("Accept", "application/json") 717 return req, nil 718} 719 720// getAdvertisedRoutesHandleError handles the GetAdvertisedRoutes error response. 721func (client *VirtualNetworkGatewaysClient) getAdvertisedRoutesHandleError(resp *azcore.Response) error { 722 body, err := resp.Payload() 723 if err != nil { 724 return azcore.NewResponseError(err, resp.Response) 725 } 726 errType := CloudError{raw: string(body)} 727 if err := resp.UnmarshalAsJSON(&errType); err != nil { 728 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 729 } 730 return azcore.NewResponseError(&errType, resp.Response) 731} 732 733// BeginGetBgpPeerStatus - The GetBgpPeerStatus operation retrieves the status of all BGP peers. 734// If the operation fails it returns the *CloudError error type. 735func (client *VirtualNetworkGatewaysClient) BeginGetBgpPeerStatus(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetBgpPeerStatusOptions) (BgpPeerStatusListResultPollerResponse, error) { 736 resp, err := client.getBgpPeerStatus(ctx, resourceGroupName, virtualNetworkGatewayName, options) 737 if err != nil { 738 return BgpPeerStatusListResultPollerResponse{}, err 739 } 740 result := BgpPeerStatusListResultPollerResponse{ 741 RawResponse: resp.Response, 742 } 743 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.GetBgpPeerStatus", "location", resp, client.con.Pipeline(), client.getBgpPeerStatusHandleError) 744 if err != nil { 745 return BgpPeerStatusListResultPollerResponse{}, err 746 } 747 poller := &bgpPeerStatusListResultPoller{ 748 pt: pt, 749 } 750 result.Poller = poller 751 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (BgpPeerStatusListResultResponse, error) { 752 return poller.pollUntilDone(ctx, frequency) 753 } 754 return result, nil 755} 756 757// ResumeGetBgpPeerStatus creates a new BgpPeerStatusListResultPoller from the specified resume token. 758// token - The value must come from a previous call to BgpPeerStatusListResultPoller.ResumeToken(). 759func (client *VirtualNetworkGatewaysClient) ResumeGetBgpPeerStatus(ctx context.Context, token string) (BgpPeerStatusListResultPollerResponse, error) { 760 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.GetBgpPeerStatus", token, client.con.Pipeline(), client.getBgpPeerStatusHandleError) 761 if err != nil { 762 return BgpPeerStatusListResultPollerResponse{}, err 763 } 764 poller := &bgpPeerStatusListResultPoller{ 765 pt: pt, 766 } 767 resp, err := poller.Poll(ctx) 768 if err != nil { 769 return BgpPeerStatusListResultPollerResponse{}, err 770 } 771 result := BgpPeerStatusListResultPollerResponse{ 772 RawResponse: resp, 773 } 774 result.Poller = poller 775 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (BgpPeerStatusListResultResponse, error) { 776 return poller.pollUntilDone(ctx, frequency) 777 } 778 return result, nil 779} 780 781// GetBgpPeerStatus - The GetBgpPeerStatus operation retrieves the status of all BGP peers. 782// If the operation fails it returns the *CloudError error type. 783func (client *VirtualNetworkGatewaysClient) getBgpPeerStatus(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetBgpPeerStatusOptions) (*azcore.Response, error) { 784 req, err := client.getBgpPeerStatusCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 785 if err != nil { 786 return nil, err 787 } 788 resp, err := client.con.Pipeline().Do(req) 789 if err != nil { 790 return nil, err 791 } 792 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 793 return nil, client.getBgpPeerStatusHandleError(resp) 794 } 795 return resp, nil 796} 797 798// getBgpPeerStatusCreateRequest creates the GetBgpPeerStatus request. 799func (client *VirtualNetworkGatewaysClient) getBgpPeerStatusCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetBgpPeerStatusOptions) (*azcore.Request, error) { 800 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getBgpPeerStatus" 801 if resourceGroupName == "" { 802 return nil, errors.New("parameter resourceGroupName cannot be empty") 803 } 804 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 805 if virtualNetworkGatewayName == "" { 806 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 807 } 808 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 809 if client.subscriptionID == "" { 810 return nil, errors.New("parameter client.subscriptionID cannot be empty") 811 } 812 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 813 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 814 if err != nil { 815 return nil, err 816 } 817 req.Telemetry(telemetryInfo) 818 reqQP := req.URL.Query() 819 if options != nil && options.Peer != nil { 820 reqQP.Set("peer", *options.Peer) 821 } 822 reqQP.Set("api-version", "2021-02-01") 823 req.URL.RawQuery = reqQP.Encode() 824 req.Header.Set("Accept", "application/json") 825 return req, nil 826} 827 828// getBgpPeerStatusHandleError handles the GetBgpPeerStatus error response. 829func (client *VirtualNetworkGatewaysClient) getBgpPeerStatusHandleError(resp *azcore.Response) error { 830 body, err := resp.Payload() 831 if err != nil { 832 return azcore.NewResponseError(err, resp.Response) 833 } 834 errType := CloudError{raw: string(body)} 835 if err := resp.UnmarshalAsJSON(&errType); err != nil { 836 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 837 } 838 return azcore.NewResponseError(&errType, resp.Response) 839} 840 841// BeginGetLearnedRoutes - This operation retrieves a list of routes the virtual network gateway has learned, including routes learned from BGP peers. 842// If the operation fails it returns the *CloudError error type. 843func (client *VirtualNetworkGatewaysClient) BeginGetLearnedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetLearnedRoutesOptions) (GatewayRouteListResultPollerResponse, error) { 844 resp, err := client.getLearnedRoutes(ctx, resourceGroupName, virtualNetworkGatewayName, options) 845 if err != nil { 846 return GatewayRouteListResultPollerResponse{}, err 847 } 848 result := GatewayRouteListResultPollerResponse{ 849 RawResponse: resp.Response, 850 } 851 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.GetLearnedRoutes", "location", resp, client.con.Pipeline(), client.getLearnedRoutesHandleError) 852 if err != nil { 853 return GatewayRouteListResultPollerResponse{}, err 854 } 855 poller := &gatewayRouteListResultPoller{ 856 pt: pt, 857 } 858 result.Poller = poller 859 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (GatewayRouteListResultResponse, error) { 860 return poller.pollUntilDone(ctx, frequency) 861 } 862 return result, nil 863} 864 865// ResumeGetLearnedRoutes creates a new GatewayRouteListResultPoller from the specified resume token. 866// token - The value must come from a previous call to GatewayRouteListResultPoller.ResumeToken(). 867func (client *VirtualNetworkGatewaysClient) ResumeGetLearnedRoutes(ctx context.Context, token string) (GatewayRouteListResultPollerResponse, error) { 868 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.GetLearnedRoutes", token, client.con.Pipeline(), client.getLearnedRoutesHandleError) 869 if err != nil { 870 return GatewayRouteListResultPollerResponse{}, err 871 } 872 poller := &gatewayRouteListResultPoller{ 873 pt: pt, 874 } 875 resp, err := poller.Poll(ctx) 876 if err != nil { 877 return GatewayRouteListResultPollerResponse{}, err 878 } 879 result := GatewayRouteListResultPollerResponse{ 880 RawResponse: resp, 881 } 882 result.Poller = poller 883 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (GatewayRouteListResultResponse, error) { 884 return poller.pollUntilDone(ctx, frequency) 885 } 886 return result, nil 887} 888 889// GetLearnedRoutes - This operation retrieves a list of routes the virtual network gateway has learned, including routes learned from BGP peers. 890// If the operation fails it returns the *CloudError error type. 891func (client *VirtualNetworkGatewaysClient) getLearnedRoutes(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetLearnedRoutesOptions) (*azcore.Response, error) { 892 req, err := client.getLearnedRoutesCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 893 if err != nil { 894 return nil, err 895 } 896 resp, err := client.con.Pipeline().Do(req) 897 if err != nil { 898 return nil, err 899 } 900 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 901 return nil, client.getLearnedRoutesHandleError(resp) 902 } 903 return resp, nil 904} 905 906// getLearnedRoutesCreateRequest creates the GetLearnedRoutes request. 907func (client *VirtualNetworkGatewaysClient) getLearnedRoutesCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetLearnedRoutesOptions) (*azcore.Request, error) { 908 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getLearnedRoutes" 909 if resourceGroupName == "" { 910 return nil, errors.New("parameter resourceGroupName cannot be empty") 911 } 912 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 913 if virtualNetworkGatewayName == "" { 914 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 915 } 916 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 917 if client.subscriptionID == "" { 918 return nil, errors.New("parameter client.subscriptionID cannot be empty") 919 } 920 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 921 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 922 if err != nil { 923 return nil, err 924 } 925 req.Telemetry(telemetryInfo) 926 reqQP := req.URL.Query() 927 reqQP.Set("api-version", "2021-02-01") 928 req.URL.RawQuery = reqQP.Encode() 929 req.Header.Set("Accept", "application/json") 930 return req, nil 931} 932 933// getLearnedRoutesHandleError handles the GetLearnedRoutes error response. 934func (client *VirtualNetworkGatewaysClient) getLearnedRoutesHandleError(resp *azcore.Response) error { 935 body, err := resp.Payload() 936 if err != nil { 937 return azcore.NewResponseError(err, resp.Response) 938 } 939 errType := CloudError{raw: string(body)} 940 if err := resp.UnmarshalAsJSON(&errType); err != nil { 941 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 942 } 943 return azcore.NewResponseError(&errType, resp.Response) 944} 945 946// BeginGetVPNProfilePackageURL - Gets pre-generated VPN profile for P2S client of the virtual network gateway in the specified resource group. The profile 947// needs to be generated first using generateVpnProfile. 948// If the operation fails it returns the *CloudError error type. 949func (client *VirtualNetworkGatewaysClient) BeginGetVPNProfilePackageURL(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVPNProfilePackageURLOptions) (StringPollerResponse, error) { 950 resp, err := client.getVPNProfilePackageURL(ctx, resourceGroupName, virtualNetworkGatewayName, options) 951 if err != nil { 952 return StringPollerResponse{}, err 953 } 954 result := StringPollerResponse{ 955 RawResponse: resp.Response, 956 } 957 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.GetVPNProfilePackageURL", "location", resp, client.con.Pipeline(), client.getVPNProfilePackageURLHandleError) 958 if err != nil { 959 return StringPollerResponse{}, err 960 } 961 poller := &stringPoller{ 962 pt: pt, 963 } 964 result.Poller = poller 965 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 966 return poller.pollUntilDone(ctx, frequency) 967 } 968 return result, nil 969} 970 971// ResumeGetVPNProfilePackageURL creates a new StringPoller from the specified resume token. 972// token - The value must come from a previous call to StringPoller.ResumeToken(). 973func (client *VirtualNetworkGatewaysClient) ResumeGetVPNProfilePackageURL(ctx context.Context, token string) (StringPollerResponse, error) { 974 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.GetVPNProfilePackageURL", token, client.con.Pipeline(), client.getVPNProfilePackageURLHandleError) 975 if err != nil { 976 return StringPollerResponse{}, err 977 } 978 poller := &stringPoller{ 979 pt: pt, 980 } 981 resp, err := poller.Poll(ctx) 982 if err != nil { 983 return StringPollerResponse{}, err 984 } 985 result := StringPollerResponse{ 986 RawResponse: resp, 987 } 988 result.Poller = poller 989 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 990 return poller.pollUntilDone(ctx, frequency) 991 } 992 return result, nil 993} 994 995// GetVPNProfilePackageURL - Gets pre-generated VPN profile for P2S client of the virtual network gateway in the specified resource group. The profile needs 996// to be generated first using generateVpnProfile. 997// If the operation fails it returns the *CloudError error type. 998func (client *VirtualNetworkGatewaysClient) getVPNProfilePackageURL(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVPNProfilePackageURLOptions) (*azcore.Response, error) { 999 req, err := client.getVPNProfilePackageURLCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1000 if err != nil { 1001 return nil, err 1002 } 1003 resp, err := client.con.Pipeline().Do(req) 1004 if err != nil { 1005 return nil, err 1006 } 1007 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 1008 return nil, client.getVPNProfilePackageURLHandleError(resp) 1009 } 1010 return resp, nil 1011} 1012 1013// getVPNProfilePackageURLCreateRequest creates the GetVPNProfilePackageURL request. 1014func (client *VirtualNetworkGatewaysClient) getVPNProfilePackageURLCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVPNProfilePackageURLOptions) (*azcore.Request, error) { 1015 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getvpnprofilepackageurl" 1016 if resourceGroupName == "" { 1017 return nil, errors.New("parameter resourceGroupName cannot be empty") 1018 } 1019 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1020 if virtualNetworkGatewayName == "" { 1021 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1022 } 1023 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1024 if client.subscriptionID == "" { 1025 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1026 } 1027 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1028 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1029 if err != nil { 1030 return nil, err 1031 } 1032 req.Telemetry(telemetryInfo) 1033 reqQP := req.URL.Query() 1034 reqQP.Set("api-version", "2021-02-01") 1035 req.URL.RawQuery = reqQP.Encode() 1036 req.Header.Set("Accept", "application/json") 1037 return req, nil 1038} 1039 1040// getVPNProfilePackageURLHandleError handles the GetVPNProfilePackageURL error response. 1041func (client *VirtualNetworkGatewaysClient) getVPNProfilePackageURLHandleError(resp *azcore.Response) error { 1042 body, err := resp.Payload() 1043 if err != nil { 1044 return azcore.NewResponseError(err, resp.Response) 1045 } 1046 errType := CloudError{raw: string(body)} 1047 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1048 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1049 } 1050 return azcore.NewResponseError(&errType, resp.Response) 1051} 1052 1053// BeginGetVpnclientConnectionHealth - Get VPN client connection health detail per P2S client connection of the virtual network gateway in the specified 1054// resource group. 1055// If the operation fails it returns the *CloudError error type. 1056func (client *VirtualNetworkGatewaysClient) BeginGetVpnclientConnectionHealth(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVpnclientConnectionHealthOptions) (VPNClientConnectionHealthDetailListResultPollerResponse, error) { 1057 resp, err := client.getVpnclientConnectionHealth(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1058 if err != nil { 1059 return VPNClientConnectionHealthDetailListResultPollerResponse{}, err 1060 } 1061 result := VPNClientConnectionHealthDetailListResultPollerResponse{ 1062 RawResponse: resp.Response, 1063 } 1064 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.GetVpnclientConnectionHealth", "location", resp, client.con.Pipeline(), client.getVpnclientConnectionHealthHandleError) 1065 if err != nil { 1066 return VPNClientConnectionHealthDetailListResultPollerResponse{}, err 1067 } 1068 poller := &vpnClientConnectionHealthDetailListResultPoller{ 1069 pt: pt, 1070 } 1071 result.Poller = poller 1072 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VPNClientConnectionHealthDetailListResultResponse, error) { 1073 return poller.pollUntilDone(ctx, frequency) 1074 } 1075 return result, nil 1076} 1077 1078// ResumeGetVpnclientConnectionHealth creates a new VPNClientConnectionHealthDetailListResultPoller from the specified resume token. 1079// token - The value must come from a previous call to VPNClientConnectionHealthDetailListResultPoller.ResumeToken(). 1080func (client *VirtualNetworkGatewaysClient) ResumeGetVpnclientConnectionHealth(ctx context.Context, token string) (VPNClientConnectionHealthDetailListResultPollerResponse, error) { 1081 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.GetVpnclientConnectionHealth", token, client.con.Pipeline(), client.getVpnclientConnectionHealthHandleError) 1082 if err != nil { 1083 return VPNClientConnectionHealthDetailListResultPollerResponse{}, err 1084 } 1085 poller := &vpnClientConnectionHealthDetailListResultPoller{ 1086 pt: pt, 1087 } 1088 resp, err := poller.Poll(ctx) 1089 if err != nil { 1090 return VPNClientConnectionHealthDetailListResultPollerResponse{}, err 1091 } 1092 result := VPNClientConnectionHealthDetailListResultPollerResponse{ 1093 RawResponse: resp, 1094 } 1095 result.Poller = poller 1096 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VPNClientConnectionHealthDetailListResultResponse, error) { 1097 return poller.pollUntilDone(ctx, frequency) 1098 } 1099 return result, nil 1100} 1101 1102// GetVpnclientConnectionHealth - Get VPN client connection health detail per P2S client connection of the virtual network gateway in the specified resource 1103// group. 1104// If the operation fails it returns the *CloudError error type. 1105func (client *VirtualNetworkGatewaysClient) getVpnclientConnectionHealth(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVpnclientConnectionHealthOptions) (*azcore.Response, error) { 1106 req, err := client.getVpnclientConnectionHealthCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1107 if err != nil { 1108 return nil, err 1109 } 1110 resp, err := client.con.Pipeline().Do(req) 1111 if err != nil { 1112 return nil, err 1113 } 1114 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 1115 return nil, client.getVpnclientConnectionHealthHandleError(resp) 1116 } 1117 return resp, nil 1118} 1119 1120// getVpnclientConnectionHealthCreateRequest creates the GetVpnclientConnectionHealth request. 1121func (client *VirtualNetworkGatewaysClient) getVpnclientConnectionHealthCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVpnclientConnectionHealthOptions) (*azcore.Request, error) { 1122 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getVpnClientConnectionHealth" 1123 if resourceGroupName == "" { 1124 return nil, errors.New("parameter resourceGroupName cannot be empty") 1125 } 1126 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1127 if virtualNetworkGatewayName == "" { 1128 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1129 } 1130 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1131 if client.subscriptionID == "" { 1132 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1133 } 1134 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1135 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1136 if err != nil { 1137 return nil, err 1138 } 1139 req.Telemetry(telemetryInfo) 1140 reqQP := req.URL.Query() 1141 reqQP.Set("api-version", "2021-02-01") 1142 req.URL.RawQuery = reqQP.Encode() 1143 req.Header.Set("Accept", "application/json") 1144 return req, nil 1145} 1146 1147// getVpnclientConnectionHealthHandleError handles the GetVpnclientConnectionHealth error response. 1148func (client *VirtualNetworkGatewaysClient) getVpnclientConnectionHealthHandleError(resp *azcore.Response) error { 1149 body, err := resp.Payload() 1150 if err != nil { 1151 return azcore.NewResponseError(err, resp.Response) 1152 } 1153 errType := CloudError{raw: string(body)} 1154 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1155 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1156 } 1157 return azcore.NewResponseError(&errType, resp.Response) 1158} 1159 1160// BeginGetVpnclientIPSecParameters - The Get VpnclientIpsecParameters operation retrieves information about the vpnclient ipsec policy for P2S client of 1161// virtual network gateway in the specified resource group through Network resource 1162// provider. 1163// If the operation fails it returns the *CloudError error type. 1164func (client *VirtualNetworkGatewaysClient) BeginGetVpnclientIPSecParameters(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVpnclientIPSecParametersOptions) (VPNClientIPsecParametersPollerResponse, error) { 1165 resp, err := client.getVpnclientIPSecParameters(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1166 if err != nil { 1167 return VPNClientIPsecParametersPollerResponse{}, err 1168 } 1169 result := VPNClientIPsecParametersPollerResponse{ 1170 RawResponse: resp.Response, 1171 } 1172 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.GetVpnclientIPSecParameters", "location", resp, client.con.Pipeline(), client.getVpnclientIPSecParametersHandleError) 1173 if err != nil { 1174 return VPNClientIPsecParametersPollerResponse{}, err 1175 } 1176 poller := &vpnClientIPSecParametersPoller{ 1177 pt: pt, 1178 } 1179 result.Poller = poller 1180 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VPNClientIPsecParametersResponse, error) { 1181 return poller.pollUntilDone(ctx, frequency) 1182 } 1183 return result, nil 1184} 1185 1186// ResumeGetVpnclientIPSecParameters creates a new VPNClientIPsecParametersPoller from the specified resume token. 1187// token - The value must come from a previous call to VPNClientIPsecParametersPoller.ResumeToken(). 1188func (client *VirtualNetworkGatewaysClient) ResumeGetVpnclientIPSecParameters(ctx context.Context, token string) (VPNClientIPsecParametersPollerResponse, error) { 1189 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.GetVpnclientIPSecParameters", token, client.con.Pipeline(), client.getVpnclientIPSecParametersHandleError) 1190 if err != nil { 1191 return VPNClientIPsecParametersPollerResponse{}, err 1192 } 1193 poller := &vpnClientIPSecParametersPoller{ 1194 pt: pt, 1195 } 1196 resp, err := poller.Poll(ctx) 1197 if err != nil { 1198 return VPNClientIPsecParametersPollerResponse{}, err 1199 } 1200 result := VPNClientIPsecParametersPollerResponse{ 1201 RawResponse: resp, 1202 } 1203 result.Poller = poller 1204 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VPNClientIPsecParametersResponse, error) { 1205 return poller.pollUntilDone(ctx, frequency) 1206 } 1207 return result, nil 1208} 1209 1210// GetVpnclientIPSecParameters - The Get VpnclientIpsecParameters operation retrieves information about the vpnclient ipsec policy for P2S client of virtual 1211// network gateway in the specified resource group through Network resource 1212// provider. 1213// If the operation fails it returns the *CloudError error type. 1214func (client *VirtualNetworkGatewaysClient) getVpnclientIPSecParameters(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVpnclientIPSecParametersOptions) (*azcore.Response, error) { 1215 req, err := client.getVpnclientIPSecParametersCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1216 if err != nil { 1217 return nil, err 1218 } 1219 resp, err := client.con.Pipeline().Do(req) 1220 if err != nil { 1221 return nil, err 1222 } 1223 if !resp.HasStatusCode(http.StatusOK) { 1224 return nil, client.getVpnclientIPSecParametersHandleError(resp) 1225 } 1226 return resp, nil 1227} 1228 1229// getVpnclientIPSecParametersCreateRequest creates the GetVpnclientIPSecParameters request. 1230func (client *VirtualNetworkGatewaysClient) getVpnclientIPSecParametersCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginGetVpnclientIPSecParametersOptions) (*azcore.Request, error) { 1231 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/getvpnclientipsecparameters" 1232 if resourceGroupName == "" { 1233 return nil, errors.New("parameter resourceGroupName cannot be empty") 1234 } 1235 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1236 if virtualNetworkGatewayName == "" { 1237 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1238 } 1239 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1240 if client.subscriptionID == "" { 1241 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1242 } 1243 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1244 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1245 if err != nil { 1246 return nil, err 1247 } 1248 req.Telemetry(telemetryInfo) 1249 reqQP := req.URL.Query() 1250 reqQP.Set("api-version", "2021-02-01") 1251 req.URL.RawQuery = reqQP.Encode() 1252 req.Header.Set("Accept", "application/json") 1253 return req, nil 1254} 1255 1256// getVpnclientIPSecParametersHandleError handles the GetVpnclientIPSecParameters error response. 1257func (client *VirtualNetworkGatewaysClient) getVpnclientIPSecParametersHandleError(resp *azcore.Response) error { 1258 body, err := resp.Payload() 1259 if err != nil { 1260 return azcore.NewResponseError(err, resp.Response) 1261 } 1262 errType := CloudError{raw: string(body)} 1263 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1264 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1265 } 1266 return azcore.NewResponseError(&errType, resp.Response) 1267} 1268 1269// List - Gets all virtual network gateways by resource group. 1270// If the operation fails it returns the *CloudError error type. 1271func (client *VirtualNetworkGatewaysClient) List(resourceGroupName string, options *VirtualNetworkGatewaysListOptions) VirtualNetworkGatewayListResultPager { 1272 return &virtualNetworkGatewayListResultPager{ 1273 pipeline: client.con.Pipeline(), 1274 requester: func(ctx context.Context) (*azcore.Request, error) { 1275 return client.listCreateRequest(ctx, resourceGroupName, options) 1276 }, 1277 responder: client.listHandleResponse, 1278 errorer: client.listHandleError, 1279 advancer: func(ctx context.Context, resp VirtualNetworkGatewayListResultResponse) (*azcore.Request, error) { 1280 return azcore.NewRequest(ctx, http.MethodGet, *resp.VirtualNetworkGatewayListResult.NextLink) 1281 }, 1282 statusCodes: []int{http.StatusOK}, 1283 } 1284} 1285 1286// listCreateRequest creates the List request. 1287func (client *VirtualNetworkGatewaysClient) listCreateRequest(ctx context.Context, resourceGroupName string, options *VirtualNetworkGatewaysListOptions) (*azcore.Request, error) { 1288 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways" 1289 if resourceGroupName == "" { 1290 return nil, errors.New("parameter resourceGroupName cannot be empty") 1291 } 1292 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1293 if client.subscriptionID == "" { 1294 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1295 } 1296 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1297 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1298 if err != nil { 1299 return nil, err 1300 } 1301 req.Telemetry(telemetryInfo) 1302 reqQP := req.URL.Query() 1303 reqQP.Set("api-version", "2021-02-01") 1304 req.URL.RawQuery = reqQP.Encode() 1305 req.Header.Set("Accept", "application/json") 1306 return req, nil 1307} 1308 1309// listHandleResponse handles the List response. 1310func (client *VirtualNetworkGatewaysClient) listHandleResponse(resp *azcore.Response) (VirtualNetworkGatewayListResultResponse, error) { 1311 var val *VirtualNetworkGatewayListResult 1312 if err := resp.UnmarshalAsJSON(&val); err != nil { 1313 return VirtualNetworkGatewayListResultResponse{}, err 1314 } 1315 return VirtualNetworkGatewayListResultResponse{RawResponse: resp.Response, VirtualNetworkGatewayListResult: val}, nil 1316} 1317 1318// listHandleError handles the List error response. 1319func (client *VirtualNetworkGatewaysClient) listHandleError(resp *azcore.Response) error { 1320 body, err := resp.Payload() 1321 if err != nil { 1322 return azcore.NewResponseError(err, resp.Response) 1323 } 1324 errType := CloudError{raw: string(body)} 1325 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1326 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1327 } 1328 return azcore.NewResponseError(&errType, resp.Response) 1329} 1330 1331// ListConnections - Gets all the connections in a virtual network gateway. 1332// If the operation fails it returns the *CloudError error type. 1333func (client *VirtualNetworkGatewaysClient) ListConnections(resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysListConnectionsOptions) VirtualNetworkGatewayListConnectionsResultPager { 1334 return &virtualNetworkGatewayListConnectionsResultPager{ 1335 pipeline: client.con.Pipeline(), 1336 requester: func(ctx context.Context) (*azcore.Request, error) { 1337 return client.listConnectionsCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1338 }, 1339 responder: client.listConnectionsHandleResponse, 1340 errorer: client.listConnectionsHandleError, 1341 advancer: func(ctx context.Context, resp VirtualNetworkGatewayListConnectionsResultResponse) (*azcore.Request, error) { 1342 return azcore.NewRequest(ctx, http.MethodGet, *resp.VirtualNetworkGatewayListConnectionsResult.NextLink) 1343 }, 1344 statusCodes: []int{http.StatusOK}, 1345 } 1346} 1347 1348// listConnectionsCreateRequest creates the ListConnections request. 1349func (client *VirtualNetworkGatewaysClient) listConnectionsCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysListConnectionsOptions) (*azcore.Request, error) { 1350 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/connections" 1351 if resourceGroupName == "" { 1352 return nil, errors.New("parameter resourceGroupName cannot be empty") 1353 } 1354 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1355 if virtualNetworkGatewayName == "" { 1356 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1357 } 1358 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1359 if client.subscriptionID == "" { 1360 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1361 } 1362 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1363 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1364 if err != nil { 1365 return nil, err 1366 } 1367 req.Telemetry(telemetryInfo) 1368 reqQP := req.URL.Query() 1369 reqQP.Set("api-version", "2021-02-01") 1370 req.URL.RawQuery = reqQP.Encode() 1371 req.Header.Set("Accept", "application/json") 1372 return req, nil 1373} 1374 1375// listConnectionsHandleResponse handles the ListConnections response. 1376func (client *VirtualNetworkGatewaysClient) listConnectionsHandleResponse(resp *azcore.Response) (VirtualNetworkGatewayListConnectionsResultResponse, error) { 1377 var val *VirtualNetworkGatewayListConnectionsResult 1378 if err := resp.UnmarshalAsJSON(&val); err != nil { 1379 return VirtualNetworkGatewayListConnectionsResultResponse{}, err 1380 } 1381 return VirtualNetworkGatewayListConnectionsResultResponse{RawResponse: resp.Response, VirtualNetworkGatewayListConnectionsResult: val}, nil 1382} 1383 1384// listConnectionsHandleError handles the ListConnections error response. 1385func (client *VirtualNetworkGatewaysClient) listConnectionsHandleError(resp *azcore.Response) error { 1386 body, err := resp.Payload() 1387 if err != nil { 1388 return azcore.NewResponseError(err, resp.Response) 1389 } 1390 errType := CloudError{raw: string(body)} 1391 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1392 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1393 } 1394 return azcore.NewResponseError(&errType, resp.Response) 1395} 1396 1397// BeginReset - Resets the primary of the virtual network gateway in the specified resource group. 1398// If the operation fails it returns the *CloudError error type. 1399func (client *VirtualNetworkGatewaysClient) BeginReset(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginResetOptions) (VirtualNetworkGatewayPollerResponse, error) { 1400 resp, err := client.reset(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1401 if err != nil { 1402 return VirtualNetworkGatewayPollerResponse{}, err 1403 } 1404 result := VirtualNetworkGatewayPollerResponse{ 1405 RawResponse: resp.Response, 1406 } 1407 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.Reset", "location", resp, client.con.Pipeline(), client.resetHandleError) 1408 if err != nil { 1409 return VirtualNetworkGatewayPollerResponse{}, err 1410 } 1411 poller := &virtualNetworkGatewayPoller{ 1412 pt: pt, 1413 } 1414 result.Poller = poller 1415 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VirtualNetworkGatewayResponse, error) { 1416 return poller.pollUntilDone(ctx, frequency) 1417 } 1418 return result, nil 1419} 1420 1421// ResumeReset creates a new VirtualNetworkGatewayPoller from the specified resume token. 1422// token - The value must come from a previous call to VirtualNetworkGatewayPoller.ResumeToken(). 1423func (client *VirtualNetworkGatewaysClient) ResumeReset(ctx context.Context, token string) (VirtualNetworkGatewayPollerResponse, error) { 1424 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.Reset", token, client.con.Pipeline(), client.resetHandleError) 1425 if err != nil { 1426 return VirtualNetworkGatewayPollerResponse{}, err 1427 } 1428 poller := &virtualNetworkGatewayPoller{ 1429 pt: pt, 1430 } 1431 resp, err := poller.Poll(ctx) 1432 if err != nil { 1433 return VirtualNetworkGatewayPollerResponse{}, err 1434 } 1435 result := VirtualNetworkGatewayPollerResponse{ 1436 RawResponse: resp, 1437 } 1438 result.Poller = poller 1439 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VirtualNetworkGatewayResponse, error) { 1440 return poller.pollUntilDone(ctx, frequency) 1441 } 1442 return result, nil 1443} 1444 1445// Reset - Resets the primary of the virtual network gateway in the specified resource group. 1446// If the operation fails it returns the *CloudError error type. 1447func (client *VirtualNetworkGatewaysClient) reset(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginResetOptions) (*azcore.Response, error) { 1448 req, err := client.resetCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1449 if err != nil { 1450 return nil, err 1451 } 1452 resp, err := client.con.Pipeline().Do(req) 1453 if err != nil { 1454 return nil, err 1455 } 1456 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 1457 return nil, client.resetHandleError(resp) 1458 } 1459 return resp, nil 1460} 1461 1462// resetCreateRequest creates the Reset request. 1463func (client *VirtualNetworkGatewaysClient) resetCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginResetOptions) (*azcore.Request, error) { 1464 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/reset" 1465 if resourceGroupName == "" { 1466 return nil, errors.New("parameter resourceGroupName cannot be empty") 1467 } 1468 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1469 if virtualNetworkGatewayName == "" { 1470 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1471 } 1472 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1473 if client.subscriptionID == "" { 1474 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1475 } 1476 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1477 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1478 if err != nil { 1479 return nil, err 1480 } 1481 req.Telemetry(telemetryInfo) 1482 reqQP := req.URL.Query() 1483 if options != nil && options.GatewayVip != nil { 1484 reqQP.Set("gatewayVip", *options.GatewayVip) 1485 } 1486 reqQP.Set("api-version", "2021-02-01") 1487 req.URL.RawQuery = reqQP.Encode() 1488 req.Header.Set("Accept", "application/json") 1489 return req, nil 1490} 1491 1492// resetHandleError handles the Reset error response. 1493func (client *VirtualNetworkGatewaysClient) resetHandleError(resp *azcore.Response) error { 1494 body, err := resp.Payload() 1495 if err != nil { 1496 return azcore.NewResponseError(err, resp.Response) 1497 } 1498 errType := CloudError{raw: string(body)} 1499 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1500 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1501 } 1502 return azcore.NewResponseError(&errType, resp.Response) 1503} 1504 1505// BeginResetVPNClientSharedKey - Resets the VPN client shared key of the virtual network gateway in the specified resource group. 1506// If the operation fails it returns the *CloudError error type. 1507func (client *VirtualNetworkGatewaysClient) BeginResetVPNClientSharedKey(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginResetVPNClientSharedKeyOptions) (HTTPPollerResponse, error) { 1508 resp, err := client.resetVPNClientSharedKey(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1509 if err != nil { 1510 return HTTPPollerResponse{}, err 1511 } 1512 result := HTTPPollerResponse{ 1513 RawResponse: resp.Response, 1514 } 1515 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.ResetVPNClientSharedKey", "location", resp, client.con.Pipeline(), client.resetVPNClientSharedKeyHandleError) 1516 if err != nil { 1517 return HTTPPollerResponse{}, err 1518 } 1519 poller := &httpPoller{ 1520 pt: pt, 1521 } 1522 result.Poller = poller 1523 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) { 1524 return poller.pollUntilDone(ctx, frequency) 1525 } 1526 return result, nil 1527} 1528 1529// ResumeResetVPNClientSharedKey creates a new HTTPPoller from the specified resume token. 1530// token - The value must come from a previous call to HTTPPoller.ResumeToken(). 1531func (client *VirtualNetworkGatewaysClient) ResumeResetVPNClientSharedKey(ctx context.Context, token string) (HTTPPollerResponse, error) { 1532 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.ResetVPNClientSharedKey", token, client.con.Pipeline(), client.resetVPNClientSharedKeyHandleError) 1533 if err != nil { 1534 return HTTPPollerResponse{}, err 1535 } 1536 poller := &httpPoller{ 1537 pt: pt, 1538 } 1539 resp, err := poller.Poll(ctx) 1540 if err != nil { 1541 return HTTPPollerResponse{}, err 1542 } 1543 result := HTTPPollerResponse{ 1544 RawResponse: resp, 1545 } 1546 result.Poller = poller 1547 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) { 1548 return poller.pollUntilDone(ctx, frequency) 1549 } 1550 return result, nil 1551} 1552 1553// ResetVPNClientSharedKey - Resets the VPN client shared key of the virtual network gateway in the specified resource group. 1554// If the operation fails it returns the *CloudError error type. 1555func (client *VirtualNetworkGatewaysClient) resetVPNClientSharedKey(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginResetVPNClientSharedKeyOptions) (*azcore.Response, error) { 1556 req, err := client.resetVPNClientSharedKeyCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1557 if err != nil { 1558 return nil, err 1559 } 1560 resp, err := client.con.Pipeline().Do(req) 1561 if err != nil { 1562 return nil, err 1563 } 1564 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 1565 return nil, client.resetVPNClientSharedKeyHandleError(resp) 1566 } 1567 return resp, nil 1568} 1569 1570// resetVPNClientSharedKeyCreateRequest creates the ResetVPNClientSharedKey request. 1571func (client *VirtualNetworkGatewaysClient) resetVPNClientSharedKeyCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginResetVPNClientSharedKeyOptions) (*azcore.Request, error) { 1572 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/resetvpnclientsharedkey" 1573 if resourceGroupName == "" { 1574 return nil, errors.New("parameter resourceGroupName cannot be empty") 1575 } 1576 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1577 if virtualNetworkGatewayName == "" { 1578 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1579 } 1580 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1581 if client.subscriptionID == "" { 1582 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1583 } 1584 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1585 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1586 if err != nil { 1587 return nil, err 1588 } 1589 req.Telemetry(telemetryInfo) 1590 reqQP := req.URL.Query() 1591 reqQP.Set("api-version", "2021-02-01") 1592 req.URL.RawQuery = reqQP.Encode() 1593 req.Header.Set("Accept", "application/json") 1594 return req, nil 1595} 1596 1597// resetVPNClientSharedKeyHandleError handles the ResetVPNClientSharedKey error response. 1598func (client *VirtualNetworkGatewaysClient) resetVPNClientSharedKeyHandleError(resp *azcore.Response) error { 1599 body, err := resp.Payload() 1600 if err != nil { 1601 return azcore.NewResponseError(err, resp.Response) 1602 } 1603 errType := CloudError{raw: string(body)} 1604 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1605 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1606 } 1607 return azcore.NewResponseError(&errType, resp.Response) 1608} 1609 1610// BeginSetVpnclientIPSecParameters - The Set VpnclientIpsecParameters operation sets the vpnclient ipsec policy for P2S client of virtual network gateway 1611// in the specified resource group through Network resource provider. 1612// If the operation fails it returns the *CloudError error type. 1613func (client *VirtualNetworkGatewaysClient) BeginSetVpnclientIPSecParameters(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, vpnclientIPSecParams VPNClientIPsecParameters, options *VirtualNetworkGatewaysBeginSetVpnclientIPSecParametersOptions) (VPNClientIPsecParametersPollerResponse, error) { 1614 resp, err := client.setVpnclientIPSecParameters(ctx, resourceGroupName, virtualNetworkGatewayName, vpnclientIPSecParams, options) 1615 if err != nil { 1616 return VPNClientIPsecParametersPollerResponse{}, err 1617 } 1618 result := VPNClientIPsecParametersPollerResponse{ 1619 RawResponse: resp.Response, 1620 } 1621 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.SetVpnclientIPSecParameters", "location", resp, client.con.Pipeline(), client.setVpnclientIPSecParametersHandleError) 1622 if err != nil { 1623 return VPNClientIPsecParametersPollerResponse{}, err 1624 } 1625 poller := &vpnClientIPSecParametersPoller{ 1626 pt: pt, 1627 } 1628 result.Poller = poller 1629 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VPNClientIPsecParametersResponse, error) { 1630 return poller.pollUntilDone(ctx, frequency) 1631 } 1632 return result, nil 1633} 1634 1635// ResumeSetVpnclientIPSecParameters creates a new VPNClientIPsecParametersPoller from the specified resume token. 1636// token - The value must come from a previous call to VPNClientIPsecParametersPoller.ResumeToken(). 1637func (client *VirtualNetworkGatewaysClient) ResumeSetVpnclientIPSecParameters(ctx context.Context, token string) (VPNClientIPsecParametersPollerResponse, error) { 1638 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.SetVpnclientIPSecParameters", token, client.con.Pipeline(), client.setVpnclientIPSecParametersHandleError) 1639 if err != nil { 1640 return VPNClientIPsecParametersPollerResponse{}, err 1641 } 1642 poller := &vpnClientIPSecParametersPoller{ 1643 pt: pt, 1644 } 1645 resp, err := poller.Poll(ctx) 1646 if err != nil { 1647 return VPNClientIPsecParametersPollerResponse{}, err 1648 } 1649 result := VPNClientIPsecParametersPollerResponse{ 1650 RawResponse: resp, 1651 } 1652 result.Poller = poller 1653 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VPNClientIPsecParametersResponse, error) { 1654 return poller.pollUntilDone(ctx, frequency) 1655 } 1656 return result, nil 1657} 1658 1659// SetVpnclientIPSecParameters - The Set VpnclientIpsecParameters operation sets the vpnclient ipsec policy for P2S client of virtual network gateway in 1660// the specified resource group through Network resource provider. 1661// If the operation fails it returns the *CloudError error type. 1662func (client *VirtualNetworkGatewaysClient) setVpnclientIPSecParameters(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, vpnclientIPSecParams VPNClientIPsecParameters, options *VirtualNetworkGatewaysBeginSetVpnclientIPSecParametersOptions) (*azcore.Response, error) { 1663 req, err := client.setVpnclientIPSecParametersCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, vpnclientIPSecParams, options) 1664 if err != nil { 1665 return nil, err 1666 } 1667 resp, err := client.con.Pipeline().Do(req) 1668 if err != nil { 1669 return nil, err 1670 } 1671 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 1672 return nil, client.setVpnclientIPSecParametersHandleError(resp) 1673 } 1674 return resp, nil 1675} 1676 1677// setVpnclientIPSecParametersCreateRequest creates the SetVpnclientIPSecParameters request. 1678func (client *VirtualNetworkGatewaysClient) setVpnclientIPSecParametersCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, vpnclientIPSecParams VPNClientIPsecParameters, options *VirtualNetworkGatewaysBeginSetVpnclientIPSecParametersOptions) (*azcore.Request, error) { 1679 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/setvpnclientipsecparameters" 1680 if resourceGroupName == "" { 1681 return nil, errors.New("parameter resourceGroupName cannot be empty") 1682 } 1683 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1684 if virtualNetworkGatewayName == "" { 1685 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1686 } 1687 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1688 if client.subscriptionID == "" { 1689 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1690 } 1691 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1692 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1693 if err != nil { 1694 return nil, err 1695 } 1696 req.Telemetry(telemetryInfo) 1697 reqQP := req.URL.Query() 1698 reqQP.Set("api-version", "2021-02-01") 1699 req.URL.RawQuery = reqQP.Encode() 1700 req.Header.Set("Accept", "application/json") 1701 return req, req.MarshalAsJSON(vpnclientIPSecParams) 1702} 1703 1704// setVpnclientIPSecParametersHandleError handles the SetVpnclientIPSecParameters error response. 1705func (client *VirtualNetworkGatewaysClient) setVpnclientIPSecParametersHandleError(resp *azcore.Response) error { 1706 body, err := resp.Payload() 1707 if err != nil { 1708 return azcore.NewResponseError(err, resp.Response) 1709 } 1710 errType := CloudError{raw: string(body)} 1711 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1712 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1713 } 1714 return azcore.NewResponseError(&errType, resp.Response) 1715} 1716 1717// BeginStartPacketCapture - Starts packet capture on virtual network gateway in the specified resource group. 1718// If the operation fails it returns the *Error error type. 1719func (client *VirtualNetworkGatewaysClient) BeginStartPacketCapture(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginStartPacketCaptureOptions) (StringPollerResponse, error) { 1720 resp, err := client.startPacketCapture(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1721 if err != nil { 1722 return StringPollerResponse{}, err 1723 } 1724 result := StringPollerResponse{ 1725 RawResponse: resp.Response, 1726 } 1727 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.StartPacketCapture", "location", resp, client.con.Pipeline(), client.startPacketCaptureHandleError) 1728 if err != nil { 1729 return StringPollerResponse{}, err 1730 } 1731 poller := &stringPoller{ 1732 pt: pt, 1733 } 1734 result.Poller = poller 1735 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 1736 return poller.pollUntilDone(ctx, frequency) 1737 } 1738 return result, nil 1739} 1740 1741// ResumeStartPacketCapture creates a new StringPoller from the specified resume token. 1742// token - The value must come from a previous call to StringPoller.ResumeToken(). 1743func (client *VirtualNetworkGatewaysClient) ResumeStartPacketCapture(ctx context.Context, token string) (StringPollerResponse, error) { 1744 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.StartPacketCapture", token, client.con.Pipeline(), client.startPacketCaptureHandleError) 1745 if err != nil { 1746 return StringPollerResponse{}, err 1747 } 1748 poller := &stringPoller{ 1749 pt: pt, 1750 } 1751 resp, err := poller.Poll(ctx) 1752 if err != nil { 1753 return StringPollerResponse{}, err 1754 } 1755 result := StringPollerResponse{ 1756 RawResponse: resp, 1757 } 1758 result.Poller = poller 1759 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 1760 return poller.pollUntilDone(ctx, frequency) 1761 } 1762 return result, nil 1763} 1764 1765// StartPacketCapture - Starts packet capture on virtual network gateway in the specified resource group. 1766// If the operation fails it returns the *Error error type. 1767func (client *VirtualNetworkGatewaysClient) startPacketCapture(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginStartPacketCaptureOptions) (*azcore.Response, error) { 1768 req, err := client.startPacketCaptureCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1769 if err != nil { 1770 return nil, err 1771 } 1772 resp, err := client.con.Pipeline().Do(req) 1773 if err != nil { 1774 return nil, err 1775 } 1776 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 1777 return nil, client.startPacketCaptureHandleError(resp) 1778 } 1779 return resp, nil 1780} 1781 1782// startPacketCaptureCreateRequest creates the StartPacketCapture request. 1783func (client *VirtualNetworkGatewaysClient) startPacketCaptureCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysBeginStartPacketCaptureOptions) (*azcore.Request, error) { 1784 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/startPacketCapture" 1785 if resourceGroupName == "" { 1786 return nil, errors.New("parameter resourceGroupName cannot be empty") 1787 } 1788 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1789 if virtualNetworkGatewayName == "" { 1790 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1791 } 1792 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1793 if client.subscriptionID == "" { 1794 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1795 } 1796 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1797 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1798 if err != nil { 1799 return nil, err 1800 } 1801 req.Telemetry(telemetryInfo) 1802 reqQP := req.URL.Query() 1803 reqQP.Set("api-version", "2021-02-01") 1804 req.URL.RawQuery = reqQP.Encode() 1805 req.Header.Set("Accept", "application/json") 1806 if options != nil && options.Parameters != nil { 1807 return req, req.MarshalAsJSON(*options.Parameters) 1808 } 1809 return req, nil 1810} 1811 1812// startPacketCaptureHandleError handles the StartPacketCapture error response. 1813func (client *VirtualNetworkGatewaysClient) startPacketCaptureHandleError(resp *azcore.Response) error { 1814 body, err := resp.Payload() 1815 if err != nil { 1816 return azcore.NewResponseError(err, resp.Response) 1817 } 1818 errType := Error{raw: string(body)} 1819 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1820 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1821 } 1822 return azcore.NewResponseError(&errType, resp.Response) 1823} 1824 1825// BeginStopPacketCapture - Stops packet capture on virtual network gateway in the specified resource group. 1826// If the operation fails it returns the *Error error type. 1827func (client *VirtualNetworkGatewaysClient) BeginStopPacketCapture(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNPacketCaptureStopParameters, options *VirtualNetworkGatewaysBeginStopPacketCaptureOptions) (StringPollerResponse, error) { 1828 resp, err := client.stopPacketCapture(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 1829 if err != nil { 1830 return StringPollerResponse{}, err 1831 } 1832 result := StringPollerResponse{ 1833 RawResponse: resp.Response, 1834 } 1835 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.StopPacketCapture", "location", resp, client.con.Pipeline(), client.stopPacketCaptureHandleError) 1836 if err != nil { 1837 return StringPollerResponse{}, err 1838 } 1839 poller := &stringPoller{ 1840 pt: pt, 1841 } 1842 result.Poller = poller 1843 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 1844 return poller.pollUntilDone(ctx, frequency) 1845 } 1846 return result, nil 1847} 1848 1849// ResumeStopPacketCapture creates a new StringPoller from the specified resume token. 1850// token - The value must come from a previous call to StringPoller.ResumeToken(). 1851func (client *VirtualNetworkGatewaysClient) ResumeStopPacketCapture(ctx context.Context, token string) (StringPollerResponse, error) { 1852 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.StopPacketCapture", token, client.con.Pipeline(), client.stopPacketCaptureHandleError) 1853 if err != nil { 1854 return StringPollerResponse{}, err 1855 } 1856 poller := &stringPoller{ 1857 pt: pt, 1858 } 1859 resp, err := poller.Poll(ctx) 1860 if err != nil { 1861 return StringPollerResponse{}, err 1862 } 1863 result := StringPollerResponse{ 1864 RawResponse: resp, 1865 } 1866 result.Poller = poller 1867 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (StringResponse, error) { 1868 return poller.pollUntilDone(ctx, frequency) 1869 } 1870 return result, nil 1871} 1872 1873// StopPacketCapture - Stops packet capture on virtual network gateway in the specified resource group. 1874// If the operation fails it returns the *Error error type. 1875func (client *VirtualNetworkGatewaysClient) stopPacketCapture(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNPacketCaptureStopParameters, options *VirtualNetworkGatewaysBeginStopPacketCaptureOptions) (*azcore.Response, error) { 1876 req, err := client.stopPacketCaptureCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 1877 if err != nil { 1878 return nil, err 1879 } 1880 resp, err := client.con.Pipeline().Do(req) 1881 if err != nil { 1882 return nil, err 1883 } 1884 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 1885 return nil, client.stopPacketCaptureHandleError(resp) 1886 } 1887 return resp, nil 1888} 1889 1890// stopPacketCaptureCreateRequest creates the StopPacketCapture request. 1891func (client *VirtualNetworkGatewaysClient) stopPacketCaptureCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters VPNPacketCaptureStopParameters, options *VirtualNetworkGatewaysBeginStopPacketCaptureOptions) (*azcore.Request, error) { 1892 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/stopPacketCapture" 1893 if resourceGroupName == "" { 1894 return nil, errors.New("parameter resourceGroupName cannot be empty") 1895 } 1896 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1897 if virtualNetworkGatewayName == "" { 1898 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1899 } 1900 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1901 if client.subscriptionID == "" { 1902 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1903 } 1904 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1905 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1906 if err != nil { 1907 return nil, err 1908 } 1909 req.Telemetry(telemetryInfo) 1910 reqQP := req.URL.Query() 1911 reqQP.Set("api-version", "2021-02-01") 1912 req.URL.RawQuery = reqQP.Encode() 1913 req.Header.Set("Accept", "application/json") 1914 return req, req.MarshalAsJSON(parameters) 1915} 1916 1917// stopPacketCaptureHandleError handles the StopPacketCapture error response. 1918func (client *VirtualNetworkGatewaysClient) stopPacketCaptureHandleError(resp *azcore.Response) error { 1919 body, err := resp.Payload() 1920 if err != nil { 1921 return azcore.NewResponseError(err, resp.Response) 1922 } 1923 errType := Error{raw: string(body)} 1924 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1925 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1926 } 1927 return azcore.NewResponseError(&errType, resp.Response) 1928} 1929 1930// SupportedVPNDevices - Gets a xml format representation for supported vpn devices. 1931// If the operation fails it returns the *CloudError error type. 1932func (client *VirtualNetworkGatewaysClient) SupportedVPNDevices(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysSupportedVPNDevicesOptions) (StringResponse, error) { 1933 req, err := client.supportedVPNDevicesCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, options) 1934 if err != nil { 1935 return StringResponse{}, err 1936 } 1937 resp, err := client.con.Pipeline().Do(req) 1938 if err != nil { 1939 return StringResponse{}, err 1940 } 1941 if !resp.HasStatusCode(http.StatusOK) { 1942 return StringResponse{}, client.supportedVPNDevicesHandleError(resp) 1943 } 1944 return client.supportedVPNDevicesHandleResponse(resp) 1945} 1946 1947// supportedVPNDevicesCreateRequest creates the SupportedVPNDevices request. 1948func (client *VirtualNetworkGatewaysClient) supportedVPNDevicesCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, options *VirtualNetworkGatewaysSupportedVPNDevicesOptions) (*azcore.Request, error) { 1949 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}/supportedvpndevices" 1950 if resourceGroupName == "" { 1951 return nil, errors.New("parameter resourceGroupName cannot be empty") 1952 } 1953 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 1954 if virtualNetworkGatewayName == "" { 1955 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 1956 } 1957 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 1958 if client.subscriptionID == "" { 1959 return nil, errors.New("parameter client.subscriptionID cannot be empty") 1960 } 1961 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 1962 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 1963 if err != nil { 1964 return nil, err 1965 } 1966 req.Telemetry(telemetryInfo) 1967 reqQP := req.URL.Query() 1968 reqQP.Set("api-version", "2021-02-01") 1969 req.URL.RawQuery = reqQP.Encode() 1970 req.Header.Set("Accept", "application/json") 1971 return req, nil 1972} 1973 1974// supportedVPNDevicesHandleResponse handles the SupportedVPNDevices response. 1975func (client *VirtualNetworkGatewaysClient) supportedVPNDevicesHandleResponse(resp *azcore.Response) (StringResponse, error) { 1976 var val *string 1977 if err := resp.UnmarshalAsJSON(&val); err != nil { 1978 return StringResponse{}, err 1979 } 1980 return StringResponse{RawResponse: resp.Response, Value: val}, nil 1981} 1982 1983// supportedVPNDevicesHandleError handles the SupportedVPNDevices error response. 1984func (client *VirtualNetworkGatewaysClient) supportedVPNDevicesHandleError(resp *azcore.Response) error { 1985 body, err := resp.Payload() 1986 if err != nil { 1987 return azcore.NewResponseError(err, resp.Response) 1988 } 1989 errType := CloudError{raw: string(body)} 1990 if err := resp.UnmarshalAsJSON(&errType); err != nil { 1991 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 1992 } 1993 return azcore.NewResponseError(&errType, resp.Response) 1994} 1995 1996// BeginUpdateTags - Updates a virtual network gateway tags. 1997// If the operation fails it returns the *CloudError error type. 1998func (client *VirtualNetworkGatewaysClient) BeginUpdateTags(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject, options *VirtualNetworkGatewaysBeginUpdateTagsOptions) (VirtualNetworkGatewayPollerResponse, error) { 1999 resp, err := client.updateTags(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 2000 if err != nil { 2001 return VirtualNetworkGatewayPollerResponse{}, err 2002 } 2003 result := VirtualNetworkGatewayPollerResponse{ 2004 RawResponse: resp.Response, 2005 } 2006 pt, err := armcore.NewLROPoller("VirtualNetworkGatewaysClient.UpdateTags", "azure-async-operation", resp, client.con.Pipeline(), client.updateTagsHandleError) 2007 if err != nil { 2008 return VirtualNetworkGatewayPollerResponse{}, err 2009 } 2010 poller := &virtualNetworkGatewayPoller{ 2011 pt: pt, 2012 } 2013 result.Poller = poller 2014 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VirtualNetworkGatewayResponse, error) { 2015 return poller.pollUntilDone(ctx, frequency) 2016 } 2017 return result, nil 2018} 2019 2020// ResumeUpdateTags creates a new VirtualNetworkGatewayPoller from the specified resume token. 2021// token - The value must come from a previous call to VirtualNetworkGatewayPoller.ResumeToken(). 2022func (client *VirtualNetworkGatewaysClient) ResumeUpdateTags(ctx context.Context, token string) (VirtualNetworkGatewayPollerResponse, error) { 2023 pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworkGatewaysClient.UpdateTags", token, client.con.Pipeline(), client.updateTagsHandleError) 2024 if err != nil { 2025 return VirtualNetworkGatewayPollerResponse{}, err 2026 } 2027 poller := &virtualNetworkGatewayPoller{ 2028 pt: pt, 2029 } 2030 resp, err := poller.Poll(ctx) 2031 if err != nil { 2032 return VirtualNetworkGatewayPollerResponse{}, err 2033 } 2034 result := VirtualNetworkGatewayPollerResponse{ 2035 RawResponse: resp, 2036 } 2037 result.Poller = poller 2038 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VirtualNetworkGatewayResponse, error) { 2039 return poller.pollUntilDone(ctx, frequency) 2040 } 2041 return result, nil 2042} 2043 2044// UpdateTags - Updates a virtual network gateway tags. 2045// If the operation fails it returns the *CloudError error type. 2046func (client *VirtualNetworkGatewaysClient) updateTags(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject, options *VirtualNetworkGatewaysBeginUpdateTagsOptions) (*azcore.Response, error) { 2047 req, err := client.updateTagsCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayName, parameters, options) 2048 if err != nil { 2049 return nil, err 2050 } 2051 resp, err := client.con.Pipeline().Do(req) 2052 if err != nil { 2053 return nil, err 2054 } 2055 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 2056 return nil, client.updateTagsHandleError(resp) 2057 } 2058 return resp, nil 2059} 2060 2061// updateTagsCreateRequest creates the UpdateTags request. 2062func (client *VirtualNetworkGatewaysClient) updateTagsCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayName string, parameters TagsObject, options *VirtualNetworkGatewaysBeginUpdateTagsOptions) (*azcore.Request, error) { 2063 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworkGateways/{virtualNetworkGatewayName}" 2064 if resourceGroupName == "" { 2065 return nil, errors.New("parameter resourceGroupName cannot be empty") 2066 } 2067 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 2068 if virtualNetworkGatewayName == "" { 2069 return nil, errors.New("parameter virtualNetworkGatewayName cannot be empty") 2070 } 2071 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayName}", url.PathEscape(virtualNetworkGatewayName)) 2072 if client.subscriptionID == "" { 2073 return nil, errors.New("parameter client.subscriptionID cannot be empty") 2074 } 2075 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 2076 req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 2077 if err != nil { 2078 return nil, err 2079 } 2080 req.Telemetry(telemetryInfo) 2081 reqQP := req.URL.Query() 2082 reqQP.Set("api-version", "2021-02-01") 2083 req.URL.RawQuery = reqQP.Encode() 2084 req.Header.Set("Accept", "application/json") 2085 return req, req.MarshalAsJSON(parameters) 2086} 2087 2088// updateTagsHandleError handles the UpdateTags error response. 2089func (client *VirtualNetworkGatewaysClient) updateTagsHandleError(resp *azcore.Response) error { 2090 body, err := resp.Payload() 2091 if err != nil { 2092 return azcore.NewResponseError(err, resp.Response) 2093 } 2094 errType := CloudError{raw: string(body)} 2095 if err := resp.UnmarshalAsJSON(&errType); err != nil { 2096 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 2097 } 2098 return azcore.NewResponseError(&errType, resp.Response) 2099} 2100 2101// VPNDeviceConfigurationScript - Gets a xml format representation for vpn device configuration script. 2102// If the operation fails it returns the *CloudError error type. 2103func (client *VirtualNetworkGatewaysClient) VPNDeviceConfigurationScript(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VPNDeviceScriptParameters, options *VirtualNetworkGatewaysVPNDeviceConfigurationScriptOptions) (StringResponse, error) { 2104 req, err := client.vpnDeviceConfigurationScriptCreateRequest(ctx, resourceGroupName, virtualNetworkGatewayConnectionName, parameters, options) 2105 if err != nil { 2106 return StringResponse{}, err 2107 } 2108 resp, err := client.con.Pipeline().Do(req) 2109 if err != nil { 2110 return StringResponse{}, err 2111 } 2112 if !resp.HasStatusCode(http.StatusOK) { 2113 return StringResponse{}, client.vpnDeviceConfigurationScriptHandleError(resp) 2114 } 2115 return client.vpnDeviceConfigurationScriptHandleResponse(resp) 2116} 2117 2118// vpnDeviceConfigurationScriptCreateRequest creates the VPNDeviceConfigurationScript request. 2119func (client *VirtualNetworkGatewaysClient) vpnDeviceConfigurationScriptCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkGatewayConnectionName string, parameters VPNDeviceScriptParameters, options *VirtualNetworkGatewaysVPNDeviceConfigurationScriptOptions) (*azcore.Request, error) { 2120 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/connections/{virtualNetworkGatewayConnectionName}/vpndeviceconfigurationscript" 2121 if resourceGroupName == "" { 2122 return nil, errors.New("parameter resourceGroupName cannot be empty") 2123 } 2124 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 2125 if virtualNetworkGatewayConnectionName == "" { 2126 return nil, errors.New("parameter virtualNetworkGatewayConnectionName cannot be empty") 2127 } 2128 urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkGatewayConnectionName}", url.PathEscape(virtualNetworkGatewayConnectionName)) 2129 if client.subscriptionID == "" { 2130 return nil, errors.New("parameter client.subscriptionID cannot be empty") 2131 } 2132 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 2133 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 2134 if err != nil { 2135 return nil, err 2136 } 2137 req.Telemetry(telemetryInfo) 2138 reqQP := req.URL.Query() 2139 reqQP.Set("api-version", "2021-02-01") 2140 req.URL.RawQuery = reqQP.Encode() 2141 req.Header.Set("Accept", "application/json") 2142 return req, req.MarshalAsJSON(parameters) 2143} 2144 2145// vpnDeviceConfigurationScriptHandleResponse handles the VPNDeviceConfigurationScript response. 2146func (client *VirtualNetworkGatewaysClient) vpnDeviceConfigurationScriptHandleResponse(resp *azcore.Response) (StringResponse, error) { 2147 var val *string 2148 if err := resp.UnmarshalAsJSON(&val); err != nil { 2149 return StringResponse{}, err 2150 } 2151 return StringResponse{RawResponse: resp.Response, Value: val}, nil 2152} 2153 2154// vpnDeviceConfigurationScriptHandleError handles the VPNDeviceConfigurationScript error response. 2155func (client *VirtualNetworkGatewaysClient) vpnDeviceConfigurationScriptHandleError(resp *azcore.Response) error { 2156 body, err := resp.Payload() 2157 if err != nil { 2158 return azcore.NewResponseError(err, resp.Response) 2159 } 2160 errType := CloudError{raw: string(body)} 2161 if err := resp.UnmarshalAsJSON(&errType); err != nil { 2162 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 2163 } 2164 return azcore.NewResponseError(&errType, resp.Response) 2165} 2166