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 armcompute 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// DiskAccessesClient contains the methods for the DiskAccesses group. 23// Don't use this type directly, use NewDiskAccessesClient() instead. 24type DiskAccessesClient struct { 25 con *armcore.Connection 26 subscriptionID string 27} 28 29// NewDiskAccessesClient creates a new instance of DiskAccessesClient with the specified values. 30func NewDiskAccessesClient(con *armcore.Connection, subscriptionID string) *DiskAccessesClient { 31 return &DiskAccessesClient{con: con, subscriptionID: subscriptionID} 32} 33 34// BeginCreateOrUpdate - Creates or updates a disk access resource 35// If the operation fails it returns the *CloudError error type. 36func (client *DiskAccessesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, diskAccessName string, diskAccess DiskAccess, options *DiskAccessesBeginCreateOrUpdateOptions) (DiskAccessPollerResponse, error) { 37 resp, err := client.createOrUpdate(ctx, resourceGroupName, diskAccessName, diskAccess, options) 38 if err != nil { 39 return DiskAccessPollerResponse{}, err 40 } 41 result := DiskAccessPollerResponse{ 42 RawResponse: resp.Response, 43 } 44 pt, err := armcore.NewLROPoller("DiskAccessesClient.CreateOrUpdate", "", resp, client.con.Pipeline(), client.createOrUpdateHandleError) 45 if err != nil { 46 return DiskAccessPollerResponse{}, err 47 } 48 poller := &diskAccessPoller{ 49 pt: pt, 50 } 51 result.Poller = poller 52 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (DiskAccessResponse, error) { 53 return poller.pollUntilDone(ctx, frequency) 54 } 55 return result, nil 56} 57 58// ResumeCreateOrUpdate creates a new DiskAccessPoller from the specified resume token. 59// token - The value must come from a previous call to DiskAccessPoller.ResumeToken(). 60func (client *DiskAccessesClient) ResumeCreateOrUpdate(ctx context.Context, token string) (DiskAccessPollerResponse, error) { 61 pt, err := armcore.NewLROPollerFromResumeToken("DiskAccessesClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError) 62 if err != nil { 63 return DiskAccessPollerResponse{}, err 64 } 65 poller := &diskAccessPoller{ 66 pt: pt, 67 } 68 resp, err := poller.Poll(ctx) 69 if err != nil { 70 return DiskAccessPollerResponse{}, err 71 } 72 result := DiskAccessPollerResponse{ 73 RawResponse: resp, 74 } 75 result.Poller = poller 76 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (DiskAccessResponse, error) { 77 return poller.pollUntilDone(ctx, frequency) 78 } 79 return result, nil 80} 81 82// CreateOrUpdate - Creates or updates a disk access resource 83// If the operation fails it returns the *CloudError error type. 84func (client *DiskAccessesClient) createOrUpdate(ctx context.Context, resourceGroupName string, diskAccessName string, diskAccess DiskAccess, options *DiskAccessesBeginCreateOrUpdateOptions) (*azcore.Response, error) { 85 req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, diskAccessName, diskAccess, 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.StatusAccepted) { 94 return nil, client.createOrUpdateHandleError(resp) 95 } 96 return resp, nil 97} 98 99// createOrUpdateCreateRequest creates the CreateOrUpdate request. 100func (client *DiskAccessesClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, diskAccess DiskAccess, options *DiskAccessesBeginCreateOrUpdateOptions) (*azcore.Request, error) { 101 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}" 102 if client.subscriptionID == "" { 103 return nil, errors.New("parameter client.subscriptionID cannot be empty") 104 } 105 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 106 if resourceGroupName == "" { 107 return nil, errors.New("parameter resourceGroupName cannot be empty") 108 } 109 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 110 if diskAccessName == "" { 111 return nil, errors.New("parameter diskAccessName cannot be empty") 112 } 113 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 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", "2020-12-01") 121 req.URL.RawQuery = reqQP.Encode() 122 req.Header.Set("Accept", "application/json") 123 return req, req.MarshalAsJSON(diskAccess) 124} 125 126// createOrUpdateHandleError handles the CreateOrUpdate error response. 127func (client *DiskAccessesClient) 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 a disk access resource. 140// If the operation fails it returns the *CloudError error type. 141func (client *DiskAccessesClient) BeginDelete(ctx context.Context, resourceGroupName string, diskAccessName string, options *DiskAccessesBeginDeleteOptions) (HTTPPollerResponse, error) { 142 resp, err := client.deleteOperation(ctx, resourceGroupName, diskAccessName, options) 143 if err != nil { 144 return HTTPPollerResponse{}, err 145 } 146 result := HTTPPollerResponse{ 147 RawResponse: resp.Response, 148 } 149 pt, err := armcore.NewLROPoller("DiskAccessesClient.Delete", "", 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 *DiskAccessesClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) { 166 pt, err := armcore.NewLROPollerFromResumeToken("DiskAccessesClient.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 a disk access resource. 188// If the operation fails it returns the *CloudError error type. 189func (client *DiskAccessesClient) deleteOperation(ctx context.Context, resourceGroupName string, diskAccessName string, options *DiskAccessesBeginDeleteOptions) (*azcore.Response, error) { 190 req, err := client.deleteCreateRequest(ctx, resourceGroupName, diskAccessName, 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 *DiskAccessesClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, options *DiskAccessesBeginDeleteOptions) (*azcore.Request, error) { 206 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}" 207 if client.subscriptionID == "" { 208 return nil, errors.New("parameter client.subscriptionID cannot be empty") 209 } 210 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 211 if resourceGroupName == "" { 212 return nil, errors.New("parameter resourceGroupName cannot be empty") 213 } 214 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 215 if diskAccessName == "" { 216 return nil, errors.New("parameter diskAccessName cannot be empty") 217 } 218 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 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", "2020-12-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 *DiskAccessesClient) 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// BeginDeleteAPrivateEndpointConnection - Deletes a private endpoint connection under a disk access resource. 245// If the operation fails it returns the *CloudError error type. 246func (client *DiskAccessesClient) BeginDeleteAPrivateEndpointConnection(ctx context.Context, resourceGroupName string, diskAccessName string, privateEndpointConnectionName string, options *DiskAccessesBeginDeleteAPrivateEndpointConnectionOptions) (HTTPPollerResponse, error) { 247 resp, err := client.deleteAPrivateEndpointConnection(ctx, resourceGroupName, diskAccessName, privateEndpointConnectionName, options) 248 if err != nil { 249 return HTTPPollerResponse{}, err 250 } 251 result := HTTPPollerResponse{ 252 RawResponse: resp.Response, 253 } 254 pt, err := armcore.NewLROPoller("DiskAccessesClient.DeleteAPrivateEndpointConnection", "", resp, client.con.Pipeline(), client.deleteAPrivateEndpointConnectionHandleError) 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// ResumeDeleteAPrivateEndpointConnection creates a new HTTPPoller from the specified resume token. 269// token - The value must come from a previous call to HTTPPoller.ResumeToken(). 270func (client *DiskAccessesClient) ResumeDeleteAPrivateEndpointConnection(ctx context.Context, token string) (HTTPPollerResponse, error) { 271 pt, err := armcore.NewLROPollerFromResumeToken("DiskAccessesClient.DeleteAPrivateEndpointConnection", token, client.con.Pipeline(), client.deleteAPrivateEndpointConnectionHandleError) 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// DeleteAPrivateEndpointConnection - Deletes a private endpoint connection under a disk access resource. 293// If the operation fails it returns the *CloudError error type. 294func (client *DiskAccessesClient) deleteAPrivateEndpointConnection(ctx context.Context, resourceGroupName string, diskAccessName string, privateEndpointConnectionName string, options *DiskAccessesBeginDeleteAPrivateEndpointConnectionOptions) (*azcore.Response, error) { 295 req, err := client.deleteAPrivateEndpointConnectionCreateRequest(ctx, resourceGroupName, diskAccessName, privateEndpointConnectionName, 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, http.StatusNoContent) { 304 return nil, client.deleteAPrivateEndpointConnectionHandleError(resp) 305 } 306 return resp, nil 307} 308 309// deleteAPrivateEndpointConnectionCreateRequest creates the DeleteAPrivateEndpointConnection request. 310func (client *DiskAccessesClient) deleteAPrivateEndpointConnectionCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, privateEndpointConnectionName string, options *DiskAccessesBeginDeleteAPrivateEndpointConnectionOptions) (*azcore.Request, error) { 311 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}/privateEndpointConnections/{privateEndpointConnectionName}" 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 diskAccessName == "" { 321 return nil, errors.New("parameter diskAccessName cannot be empty") 322 } 323 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 324 if privateEndpointConnectionName == "" { 325 return nil, errors.New("parameter privateEndpointConnectionName cannot be empty") 326 } 327 urlPath = strings.ReplaceAll(urlPath, "{privateEndpointConnectionName}", url.PathEscape(privateEndpointConnectionName)) 328 req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 329 if err != nil { 330 return nil, err 331 } 332 req.Telemetry(telemetryInfo) 333 reqQP := req.URL.Query() 334 reqQP.Set("api-version", "2020-12-01") 335 req.URL.RawQuery = reqQP.Encode() 336 req.Header.Set("Accept", "application/json") 337 return req, nil 338} 339 340// deleteAPrivateEndpointConnectionHandleError handles the DeleteAPrivateEndpointConnection error response. 341func (client *DiskAccessesClient) deleteAPrivateEndpointConnectionHandleError(resp *azcore.Response) error { 342 body, err := resp.Payload() 343 if err != nil { 344 return azcore.NewResponseError(err, resp.Response) 345 } 346 errType := CloudError{raw: string(body)} 347 if err := resp.UnmarshalAsJSON(&errType); err != nil { 348 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 349 } 350 return azcore.NewResponseError(&errType, resp.Response) 351} 352 353// Get - Gets information about a disk access resource. 354// If the operation fails it returns the *CloudError error type. 355func (client *DiskAccessesClient) Get(ctx context.Context, resourceGroupName string, diskAccessName string, options *DiskAccessesGetOptions) (DiskAccessResponse, error) { 356 req, err := client.getCreateRequest(ctx, resourceGroupName, diskAccessName, options) 357 if err != nil { 358 return DiskAccessResponse{}, err 359 } 360 resp, err := client.con.Pipeline().Do(req) 361 if err != nil { 362 return DiskAccessResponse{}, err 363 } 364 if !resp.HasStatusCode(http.StatusOK) { 365 return DiskAccessResponse{}, client.getHandleError(resp) 366 } 367 return client.getHandleResponse(resp) 368} 369 370// getCreateRequest creates the Get request. 371func (client *DiskAccessesClient) getCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, options *DiskAccessesGetOptions) (*azcore.Request, error) { 372 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}" 373 if client.subscriptionID == "" { 374 return nil, errors.New("parameter client.subscriptionID cannot be empty") 375 } 376 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 377 if resourceGroupName == "" { 378 return nil, errors.New("parameter resourceGroupName cannot be empty") 379 } 380 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 381 if diskAccessName == "" { 382 return nil, errors.New("parameter diskAccessName cannot be empty") 383 } 384 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 385 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 386 if err != nil { 387 return nil, err 388 } 389 req.Telemetry(telemetryInfo) 390 reqQP := req.URL.Query() 391 reqQP.Set("api-version", "2020-12-01") 392 req.URL.RawQuery = reqQP.Encode() 393 req.Header.Set("Accept", "application/json") 394 return req, nil 395} 396 397// getHandleResponse handles the Get response. 398func (client *DiskAccessesClient) getHandleResponse(resp *azcore.Response) (DiskAccessResponse, error) { 399 var val *DiskAccess 400 if err := resp.UnmarshalAsJSON(&val); err != nil { 401 return DiskAccessResponse{}, err 402 } 403 return DiskAccessResponse{RawResponse: resp.Response, DiskAccess: val}, nil 404} 405 406// getHandleError handles the Get error response. 407func (client *DiskAccessesClient) getHandleError(resp *azcore.Response) error { 408 body, err := resp.Payload() 409 if err != nil { 410 return azcore.NewResponseError(err, resp.Response) 411 } 412 errType := CloudError{raw: string(body)} 413 if err := resp.UnmarshalAsJSON(&errType); err != nil { 414 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 415 } 416 return azcore.NewResponseError(&errType, resp.Response) 417} 418 419// GetAPrivateEndpointConnection - Gets information about a private endpoint connection under a disk access resource. 420// If the operation fails it returns the *CloudError error type. 421func (client *DiskAccessesClient) GetAPrivateEndpointConnection(ctx context.Context, resourceGroupName string, diskAccessName string, privateEndpointConnectionName string, options *DiskAccessesGetAPrivateEndpointConnectionOptions) (PrivateEndpointConnectionResponse, error) { 422 req, err := client.getAPrivateEndpointConnectionCreateRequest(ctx, resourceGroupName, diskAccessName, privateEndpointConnectionName, options) 423 if err != nil { 424 return PrivateEndpointConnectionResponse{}, err 425 } 426 resp, err := client.con.Pipeline().Do(req) 427 if err != nil { 428 return PrivateEndpointConnectionResponse{}, err 429 } 430 if !resp.HasStatusCode(http.StatusOK) { 431 return PrivateEndpointConnectionResponse{}, client.getAPrivateEndpointConnectionHandleError(resp) 432 } 433 return client.getAPrivateEndpointConnectionHandleResponse(resp) 434} 435 436// getAPrivateEndpointConnectionCreateRequest creates the GetAPrivateEndpointConnection request. 437func (client *DiskAccessesClient) getAPrivateEndpointConnectionCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, privateEndpointConnectionName string, options *DiskAccessesGetAPrivateEndpointConnectionOptions) (*azcore.Request, error) { 438 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}/privateEndpointConnections/{privateEndpointConnectionName}" 439 if client.subscriptionID == "" { 440 return nil, errors.New("parameter client.subscriptionID cannot be empty") 441 } 442 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 443 if resourceGroupName == "" { 444 return nil, errors.New("parameter resourceGroupName cannot be empty") 445 } 446 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 447 if diskAccessName == "" { 448 return nil, errors.New("parameter diskAccessName cannot be empty") 449 } 450 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 451 if privateEndpointConnectionName == "" { 452 return nil, errors.New("parameter privateEndpointConnectionName cannot be empty") 453 } 454 urlPath = strings.ReplaceAll(urlPath, "{privateEndpointConnectionName}", url.PathEscape(privateEndpointConnectionName)) 455 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 456 if err != nil { 457 return nil, err 458 } 459 req.Telemetry(telemetryInfo) 460 reqQP := req.URL.Query() 461 reqQP.Set("api-version", "2020-12-01") 462 req.URL.RawQuery = reqQP.Encode() 463 req.Header.Set("Accept", "application/json") 464 return req, nil 465} 466 467// getAPrivateEndpointConnectionHandleResponse handles the GetAPrivateEndpointConnection response. 468func (client *DiskAccessesClient) getAPrivateEndpointConnectionHandleResponse(resp *azcore.Response) (PrivateEndpointConnectionResponse, error) { 469 var val *PrivateEndpointConnection 470 if err := resp.UnmarshalAsJSON(&val); err != nil { 471 return PrivateEndpointConnectionResponse{}, err 472 } 473 return PrivateEndpointConnectionResponse{RawResponse: resp.Response, PrivateEndpointConnection: val}, nil 474} 475 476// getAPrivateEndpointConnectionHandleError handles the GetAPrivateEndpointConnection error response. 477func (client *DiskAccessesClient) getAPrivateEndpointConnectionHandleError(resp *azcore.Response) error { 478 body, err := resp.Payload() 479 if err != nil { 480 return azcore.NewResponseError(err, resp.Response) 481 } 482 errType := CloudError{raw: string(body)} 483 if err := resp.UnmarshalAsJSON(&errType); err != nil { 484 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 485 } 486 return azcore.NewResponseError(&errType, resp.Response) 487} 488 489// GetPrivateLinkResources - Gets the private link resources possible under disk access resource 490// If the operation fails it returns a generic error. 491func (client *DiskAccessesClient) GetPrivateLinkResources(ctx context.Context, resourceGroupName string, diskAccessName string, options *DiskAccessesGetPrivateLinkResourcesOptions) (PrivateLinkResourceListResultResponse, error) { 492 req, err := client.getPrivateLinkResourcesCreateRequest(ctx, resourceGroupName, diskAccessName, options) 493 if err != nil { 494 return PrivateLinkResourceListResultResponse{}, err 495 } 496 resp, err := client.con.Pipeline().Do(req) 497 if err != nil { 498 return PrivateLinkResourceListResultResponse{}, err 499 } 500 if !resp.HasStatusCode(http.StatusOK) { 501 return PrivateLinkResourceListResultResponse{}, client.getPrivateLinkResourcesHandleError(resp) 502 } 503 return client.getPrivateLinkResourcesHandleResponse(resp) 504} 505 506// getPrivateLinkResourcesCreateRequest creates the GetPrivateLinkResources request. 507func (client *DiskAccessesClient) getPrivateLinkResourcesCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, options *DiskAccessesGetPrivateLinkResourcesOptions) (*azcore.Request, error) { 508 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}/privateLinkResources" 509 if client.subscriptionID == "" { 510 return nil, errors.New("parameter client.subscriptionID cannot be empty") 511 } 512 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 513 if resourceGroupName == "" { 514 return nil, errors.New("parameter resourceGroupName cannot be empty") 515 } 516 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 517 if diskAccessName == "" { 518 return nil, errors.New("parameter diskAccessName cannot be empty") 519 } 520 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 521 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 522 if err != nil { 523 return nil, err 524 } 525 req.Telemetry(telemetryInfo) 526 reqQP := req.URL.Query() 527 reqQP.Set("api-version", "2020-12-01") 528 req.URL.RawQuery = reqQP.Encode() 529 req.Header.Set("Accept", "application/json") 530 return req, nil 531} 532 533// getPrivateLinkResourcesHandleResponse handles the GetPrivateLinkResources response. 534func (client *DiskAccessesClient) getPrivateLinkResourcesHandleResponse(resp *azcore.Response) (PrivateLinkResourceListResultResponse, error) { 535 var val *PrivateLinkResourceListResult 536 if err := resp.UnmarshalAsJSON(&val); err != nil { 537 return PrivateLinkResourceListResultResponse{}, err 538 } 539 return PrivateLinkResourceListResultResponse{RawResponse: resp.Response, PrivateLinkResourceListResult: val}, nil 540} 541 542// getPrivateLinkResourcesHandleError handles the GetPrivateLinkResources error response. 543func (client *DiskAccessesClient) getPrivateLinkResourcesHandleError(resp *azcore.Response) error { 544 body, err := resp.Payload() 545 if err != nil { 546 return azcore.NewResponseError(err, resp.Response) 547 } 548 if len(body) == 0 { 549 return azcore.NewResponseError(errors.New(resp.Status), resp.Response) 550 } 551 return azcore.NewResponseError(errors.New(string(body)), resp.Response) 552} 553 554// List - Lists all the disk access resources under a subscription. 555// If the operation fails it returns the *CloudError error type. 556func (client *DiskAccessesClient) List(options *DiskAccessesListOptions) DiskAccessListPager { 557 return &diskAccessListPager{ 558 pipeline: client.con.Pipeline(), 559 requester: func(ctx context.Context) (*azcore.Request, error) { 560 return client.listCreateRequest(ctx, options) 561 }, 562 responder: client.listHandleResponse, 563 errorer: client.listHandleError, 564 advancer: func(ctx context.Context, resp DiskAccessListResponse) (*azcore.Request, error) { 565 return azcore.NewRequest(ctx, http.MethodGet, *resp.DiskAccessList.NextLink) 566 }, 567 statusCodes: []int{http.StatusOK}, 568 } 569} 570 571// listCreateRequest creates the List request. 572func (client *DiskAccessesClient) listCreateRequest(ctx context.Context, options *DiskAccessesListOptions) (*azcore.Request, error) { 573 urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Compute/diskAccesses" 574 if client.subscriptionID == "" { 575 return nil, errors.New("parameter client.subscriptionID cannot be empty") 576 } 577 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 578 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 579 if err != nil { 580 return nil, err 581 } 582 req.Telemetry(telemetryInfo) 583 reqQP := req.URL.Query() 584 reqQP.Set("api-version", "2020-12-01") 585 req.URL.RawQuery = reqQP.Encode() 586 req.Header.Set("Accept", "application/json") 587 return req, nil 588} 589 590// listHandleResponse handles the List response. 591func (client *DiskAccessesClient) listHandleResponse(resp *azcore.Response) (DiskAccessListResponse, error) { 592 var val *DiskAccessList 593 if err := resp.UnmarshalAsJSON(&val); err != nil { 594 return DiskAccessListResponse{}, err 595 } 596 return DiskAccessListResponse{RawResponse: resp.Response, DiskAccessList: val}, nil 597} 598 599// listHandleError handles the List error response. 600func (client *DiskAccessesClient) listHandleError(resp *azcore.Response) error { 601 body, err := resp.Payload() 602 if err != nil { 603 return azcore.NewResponseError(err, resp.Response) 604 } 605 errType := CloudError{raw: string(body)} 606 if err := resp.UnmarshalAsJSON(&errType); err != nil { 607 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 608 } 609 return azcore.NewResponseError(&errType, resp.Response) 610} 611 612// ListByResourceGroup - Lists all the disk access resources under a resource group. 613// If the operation fails it returns the *CloudError error type. 614func (client *DiskAccessesClient) ListByResourceGroup(resourceGroupName string, options *DiskAccessesListByResourceGroupOptions) DiskAccessListPager { 615 return &diskAccessListPager{ 616 pipeline: client.con.Pipeline(), 617 requester: func(ctx context.Context) (*azcore.Request, error) { 618 return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options) 619 }, 620 responder: client.listByResourceGroupHandleResponse, 621 errorer: client.listByResourceGroupHandleError, 622 advancer: func(ctx context.Context, resp DiskAccessListResponse) (*azcore.Request, error) { 623 return azcore.NewRequest(ctx, http.MethodGet, *resp.DiskAccessList.NextLink) 624 }, 625 statusCodes: []int{http.StatusOK}, 626 } 627} 628 629// listByResourceGroupCreateRequest creates the ListByResourceGroup request. 630func (client *DiskAccessesClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *DiskAccessesListByResourceGroupOptions) (*azcore.Request, error) { 631 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses" 632 if client.subscriptionID == "" { 633 return nil, errors.New("parameter client.subscriptionID cannot be empty") 634 } 635 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 636 if resourceGroupName == "" { 637 return nil, errors.New("parameter resourceGroupName cannot be empty") 638 } 639 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 640 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 641 if err != nil { 642 return nil, err 643 } 644 req.Telemetry(telemetryInfo) 645 reqQP := req.URL.Query() 646 reqQP.Set("api-version", "2020-12-01") 647 req.URL.RawQuery = reqQP.Encode() 648 req.Header.Set("Accept", "application/json") 649 return req, nil 650} 651 652// listByResourceGroupHandleResponse handles the ListByResourceGroup response. 653func (client *DiskAccessesClient) listByResourceGroupHandleResponse(resp *azcore.Response) (DiskAccessListResponse, error) { 654 var val *DiskAccessList 655 if err := resp.UnmarshalAsJSON(&val); err != nil { 656 return DiskAccessListResponse{}, err 657 } 658 return DiskAccessListResponse{RawResponse: resp.Response, DiskAccessList: val}, nil 659} 660 661// listByResourceGroupHandleError handles the ListByResourceGroup error response. 662func (client *DiskAccessesClient) listByResourceGroupHandleError(resp *azcore.Response) error { 663 body, err := resp.Payload() 664 if err != nil { 665 return azcore.NewResponseError(err, resp.Response) 666 } 667 errType := CloudError{raw: string(body)} 668 if err := resp.UnmarshalAsJSON(&errType); err != nil { 669 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 670 } 671 return azcore.NewResponseError(&errType, resp.Response) 672} 673 674// ListPrivateEndpointConnections - List information about private endpoint connections under a disk access resource 675// If the operation fails it returns the *CloudError error type. 676func (client *DiskAccessesClient) ListPrivateEndpointConnections(resourceGroupName string, diskAccessName string, options *DiskAccessesListPrivateEndpointConnectionsOptions) PrivateEndpointConnectionListResultPager { 677 return &privateEndpointConnectionListResultPager{ 678 pipeline: client.con.Pipeline(), 679 requester: func(ctx context.Context) (*azcore.Request, error) { 680 return client.listPrivateEndpointConnectionsCreateRequest(ctx, resourceGroupName, diskAccessName, options) 681 }, 682 responder: client.listPrivateEndpointConnectionsHandleResponse, 683 errorer: client.listPrivateEndpointConnectionsHandleError, 684 advancer: func(ctx context.Context, resp PrivateEndpointConnectionListResultResponse) (*azcore.Request, error) { 685 return azcore.NewRequest(ctx, http.MethodGet, *resp.PrivateEndpointConnectionListResult.NextLink) 686 }, 687 statusCodes: []int{http.StatusOK}, 688 } 689} 690 691// listPrivateEndpointConnectionsCreateRequest creates the ListPrivateEndpointConnections request. 692func (client *DiskAccessesClient) listPrivateEndpointConnectionsCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, options *DiskAccessesListPrivateEndpointConnectionsOptions) (*azcore.Request, error) { 693 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}/privateEndpointConnections" 694 if client.subscriptionID == "" { 695 return nil, errors.New("parameter client.subscriptionID cannot be empty") 696 } 697 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 698 if resourceGroupName == "" { 699 return nil, errors.New("parameter resourceGroupName cannot be empty") 700 } 701 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 702 if diskAccessName == "" { 703 return nil, errors.New("parameter diskAccessName cannot be empty") 704 } 705 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 706 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 707 if err != nil { 708 return nil, err 709 } 710 req.Telemetry(telemetryInfo) 711 reqQP := req.URL.Query() 712 reqQP.Set("api-version", "2020-12-01") 713 req.URL.RawQuery = reqQP.Encode() 714 req.Header.Set("Accept", "application/json") 715 return req, nil 716} 717 718// listPrivateEndpointConnectionsHandleResponse handles the ListPrivateEndpointConnections response. 719func (client *DiskAccessesClient) listPrivateEndpointConnectionsHandleResponse(resp *azcore.Response) (PrivateEndpointConnectionListResultResponse, error) { 720 var val *PrivateEndpointConnectionListResult 721 if err := resp.UnmarshalAsJSON(&val); err != nil { 722 return PrivateEndpointConnectionListResultResponse{}, err 723 } 724 return PrivateEndpointConnectionListResultResponse{RawResponse: resp.Response, PrivateEndpointConnectionListResult: val}, nil 725} 726 727// listPrivateEndpointConnectionsHandleError handles the ListPrivateEndpointConnections error response. 728func (client *DiskAccessesClient) listPrivateEndpointConnectionsHandleError(resp *azcore.Response) error { 729 body, err := resp.Payload() 730 if err != nil { 731 return azcore.NewResponseError(err, resp.Response) 732 } 733 errType := CloudError{raw: string(body)} 734 if err := resp.UnmarshalAsJSON(&errType); err != nil { 735 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 736 } 737 return azcore.NewResponseError(&errType, resp.Response) 738} 739 740// BeginUpdate - Updates (patches) a disk access resource. 741// If the operation fails it returns the *CloudError error type. 742func (client *DiskAccessesClient) BeginUpdate(ctx context.Context, resourceGroupName string, diskAccessName string, diskAccess DiskAccessUpdate, options *DiskAccessesBeginUpdateOptions) (DiskAccessPollerResponse, error) { 743 resp, err := client.update(ctx, resourceGroupName, diskAccessName, diskAccess, options) 744 if err != nil { 745 return DiskAccessPollerResponse{}, err 746 } 747 result := DiskAccessPollerResponse{ 748 RawResponse: resp.Response, 749 } 750 pt, err := armcore.NewLROPoller("DiskAccessesClient.Update", "", resp, client.con.Pipeline(), client.updateHandleError) 751 if err != nil { 752 return DiskAccessPollerResponse{}, err 753 } 754 poller := &diskAccessPoller{ 755 pt: pt, 756 } 757 result.Poller = poller 758 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (DiskAccessResponse, error) { 759 return poller.pollUntilDone(ctx, frequency) 760 } 761 return result, nil 762} 763 764// ResumeUpdate creates a new DiskAccessPoller from the specified resume token. 765// token - The value must come from a previous call to DiskAccessPoller.ResumeToken(). 766func (client *DiskAccessesClient) ResumeUpdate(ctx context.Context, token string) (DiskAccessPollerResponse, error) { 767 pt, err := armcore.NewLROPollerFromResumeToken("DiskAccessesClient.Update", token, client.con.Pipeline(), client.updateHandleError) 768 if err != nil { 769 return DiskAccessPollerResponse{}, err 770 } 771 poller := &diskAccessPoller{ 772 pt: pt, 773 } 774 resp, err := poller.Poll(ctx) 775 if err != nil { 776 return DiskAccessPollerResponse{}, err 777 } 778 result := DiskAccessPollerResponse{ 779 RawResponse: resp, 780 } 781 result.Poller = poller 782 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (DiskAccessResponse, error) { 783 return poller.pollUntilDone(ctx, frequency) 784 } 785 return result, nil 786} 787 788// Update - Updates (patches) a disk access resource. 789// If the operation fails it returns the *CloudError error type. 790func (client *DiskAccessesClient) update(ctx context.Context, resourceGroupName string, diskAccessName string, diskAccess DiskAccessUpdate, options *DiskAccessesBeginUpdateOptions) (*azcore.Response, error) { 791 req, err := client.updateCreateRequest(ctx, resourceGroupName, diskAccessName, diskAccess, options) 792 if err != nil { 793 return nil, err 794 } 795 resp, err := client.con.Pipeline().Do(req) 796 if err != nil { 797 return nil, err 798 } 799 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 800 return nil, client.updateHandleError(resp) 801 } 802 return resp, nil 803} 804 805// updateCreateRequest creates the Update request. 806func (client *DiskAccessesClient) updateCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, diskAccess DiskAccessUpdate, options *DiskAccessesBeginUpdateOptions) (*azcore.Request, error) { 807 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}" 808 if client.subscriptionID == "" { 809 return nil, errors.New("parameter client.subscriptionID cannot be empty") 810 } 811 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 812 if resourceGroupName == "" { 813 return nil, errors.New("parameter resourceGroupName cannot be empty") 814 } 815 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 816 if diskAccessName == "" { 817 return nil, errors.New("parameter diskAccessName cannot be empty") 818 } 819 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 820 req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 821 if err != nil { 822 return nil, err 823 } 824 req.Telemetry(telemetryInfo) 825 reqQP := req.URL.Query() 826 reqQP.Set("api-version", "2020-12-01") 827 req.URL.RawQuery = reqQP.Encode() 828 req.Header.Set("Accept", "application/json") 829 return req, req.MarshalAsJSON(diskAccess) 830} 831 832// updateHandleError handles the Update error response. 833func (client *DiskAccessesClient) updateHandleError(resp *azcore.Response) error { 834 body, err := resp.Payload() 835 if err != nil { 836 return azcore.NewResponseError(err, resp.Response) 837 } 838 errType := CloudError{raw: string(body)} 839 if err := resp.UnmarshalAsJSON(&errType); err != nil { 840 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 841 } 842 return azcore.NewResponseError(&errType, resp.Response) 843} 844 845// BeginUpdateAPrivateEndpointConnection - Approve or reject a private endpoint connection under disk access resource, this can't be used to create a new 846// private endpoint connection. 847// If the operation fails it returns the *CloudError error type. 848func (client *DiskAccessesClient) BeginUpdateAPrivateEndpointConnection(ctx context.Context, resourceGroupName string, diskAccessName string, privateEndpointConnectionName string, privateEndpointConnection PrivateEndpointConnection, options *DiskAccessesBeginUpdateAPrivateEndpointConnectionOptions) (PrivateEndpointConnectionPollerResponse, error) { 849 resp, err := client.updateAPrivateEndpointConnection(ctx, resourceGroupName, diskAccessName, privateEndpointConnectionName, privateEndpointConnection, options) 850 if err != nil { 851 return PrivateEndpointConnectionPollerResponse{}, err 852 } 853 result := PrivateEndpointConnectionPollerResponse{ 854 RawResponse: resp.Response, 855 } 856 pt, err := armcore.NewLROPoller("DiskAccessesClient.UpdateAPrivateEndpointConnection", "", resp, client.con.Pipeline(), client.updateAPrivateEndpointConnectionHandleError) 857 if err != nil { 858 return PrivateEndpointConnectionPollerResponse{}, err 859 } 860 poller := &privateEndpointConnectionPoller{ 861 pt: pt, 862 } 863 result.Poller = poller 864 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (PrivateEndpointConnectionResponse, error) { 865 return poller.pollUntilDone(ctx, frequency) 866 } 867 return result, nil 868} 869 870// ResumeUpdateAPrivateEndpointConnection creates a new PrivateEndpointConnectionPoller from the specified resume token. 871// token - The value must come from a previous call to PrivateEndpointConnectionPoller.ResumeToken(). 872func (client *DiskAccessesClient) ResumeUpdateAPrivateEndpointConnection(ctx context.Context, token string) (PrivateEndpointConnectionPollerResponse, error) { 873 pt, err := armcore.NewLROPollerFromResumeToken("DiskAccessesClient.UpdateAPrivateEndpointConnection", token, client.con.Pipeline(), client.updateAPrivateEndpointConnectionHandleError) 874 if err != nil { 875 return PrivateEndpointConnectionPollerResponse{}, err 876 } 877 poller := &privateEndpointConnectionPoller{ 878 pt: pt, 879 } 880 resp, err := poller.Poll(ctx) 881 if err != nil { 882 return PrivateEndpointConnectionPollerResponse{}, err 883 } 884 result := PrivateEndpointConnectionPollerResponse{ 885 RawResponse: resp, 886 } 887 result.Poller = poller 888 result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (PrivateEndpointConnectionResponse, error) { 889 return poller.pollUntilDone(ctx, frequency) 890 } 891 return result, nil 892} 893 894// UpdateAPrivateEndpointConnection - Approve or reject a private endpoint connection under disk access resource, this can't be used to create a new private 895// endpoint connection. 896// If the operation fails it returns the *CloudError error type. 897func (client *DiskAccessesClient) updateAPrivateEndpointConnection(ctx context.Context, resourceGroupName string, diskAccessName string, privateEndpointConnectionName string, privateEndpointConnection PrivateEndpointConnection, options *DiskAccessesBeginUpdateAPrivateEndpointConnectionOptions) (*azcore.Response, error) { 898 req, err := client.updateAPrivateEndpointConnectionCreateRequest(ctx, resourceGroupName, diskAccessName, privateEndpointConnectionName, privateEndpointConnection, options) 899 if err != nil { 900 return nil, err 901 } 902 resp, err := client.con.Pipeline().Do(req) 903 if err != nil { 904 return nil, err 905 } 906 if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) { 907 return nil, client.updateAPrivateEndpointConnectionHandleError(resp) 908 } 909 return resp, nil 910} 911 912// updateAPrivateEndpointConnectionCreateRequest creates the UpdateAPrivateEndpointConnection request. 913func (client *DiskAccessesClient) updateAPrivateEndpointConnectionCreateRequest(ctx context.Context, resourceGroupName string, diskAccessName string, privateEndpointConnectionName string, privateEndpointConnection PrivateEndpointConnection, options *DiskAccessesBeginUpdateAPrivateEndpointConnectionOptions) (*azcore.Request, error) { 914 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskAccesses/{diskAccessName}/privateEndpointConnections/{privateEndpointConnectionName}" 915 if client.subscriptionID == "" { 916 return nil, errors.New("parameter client.subscriptionID cannot be empty") 917 } 918 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 919 if resourceGroupName == "" { 920 return nil, errors.New("parameter resourceGroupName cannot be empty") 921 } 922 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 923 if diskAccessName == "" { 924 return nil, errors.New("parameter diskAccessName cannot be empty") 925 } 926 urlPath = strings.ReplaceAll(urlPath, "{diskAccessName}", url.PathEscape(diskAccessName)) 927 if privateEndpointConnectionName == "" { 928 return nil, errors.New("parameter privateEndpointConnectionName cannot be empty") 929 } 930 urlPath = strings.ReplaceAll(urlPath, "{privateEndpointConnectionName}", url.PathEscape(privateEndpointConnectionName)) 931 req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 932 if err != nil { 933 return nil, err 934 } 935 req.Telemetry(telemetryInfo) 936 reqQP := req.URL.Query() 937 reqQP.Set("api-version", "2020-12-01") 938 req.URL.RawQuery = reqQP.Encode() 939 req.Header.Set("Accept", "application/json") 940 return req, req.MarshalAsJSON(privateEndpointConnection) 941} 942 943// updateAPrivateEndpointConnectionHandleError handles the UpdateAPrivateEndpointConnection error response. 944func (client *DiskAccessesClient) updateAPrivateEndpointConnectionHandleError(resp *azcore.Response) error { 945 body, err := resp.Payload() 946 if err != nil { 947 return azcore.NewResponseError(err, resp.Response) 948 } 949 errType := CloudError{raw: string(body)} 950 if err := resp.UnmarshalAsJSON(&errType); err != nil { 951 return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response) 952 } 953 return azcore.NewResponseError(&errType, resp.Response) 954} 955