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 "github.com/Azure/azure-sdk-for-go/sdk/armcore" 14 "github.com/Azure/azure-sdk-for-go/sdk/azcore" 15 "net/http" 16 "net/url" 17 "strings" 18) 19 20// SSHPublicKeysClient contains the methods for the SSHPublicKeys group. 21// Don't use this type directly, use NewSSHPublicKeysClient() instead. 22type SSHPublicKeysClient struct { 23 con *armcore.Connection 24 subscriptionID string 25} 26 27// NewSSHPublicKeysClient creates a new instance of SSHPublicKeysClient with the specified values. 28func NewSSHPublicKeysClient(con *armcore.Connection, subscriptionID string) *SSHPublicKeysClient { 29 return &SSHPublicKeysClient{con: con, subscriptionID: subscriptionID} 30} 31 32// Create - Creates a new SSH public key resource. 33// If the operation fails it returns a generic error. 34func (client *SSHPublicKeysClient) Create(ctx context.Context, resourceGroupName string, sshPublicKeyName string, parameters SSHPublicKeyResource, options *SSHPublicKeysCreateOptions) (SSHPublicKeyResourceResponse, error) { 35 req, err := client.createCreateRequest(ctx, resourceGroupName, sshPublicKeyName, parameters, options) 36 if err != nil { 37 return SSHPublicKeyResourceResponse{}, err 38 } 39 resp, err := client.con.Pipeline().Do(req) 40 if err != nil { 41 return SSHPublicKeyResourceResponse{}, err 42 } 43 if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) { 44 return SSHPublicKeyResourceResponse{}, client.createHandleError(resp) 45 } 46 return client.createHandleResponse(resp) 47} 48 49// createCreateRequest creates the Create request. 50func (client *SSHPublicKeysClient) createCreateRequest(ctx context.Context, resourceGroupName string, sshPublicKeyName string, parameters SSHPublicKeyResource, options *SSHPublicKeysCreateOptions) (*azcore.Request, error) { 51 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/sshPublicKeys/{sshPublicKeyName}" 52 if resourceGroupName == "" { 53 return nil, errors.New("parameter resourceGroupName cannot be empty") 54 } 55 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 56 if sshPublicKeyName == "" { 57 return nil, errors.New("parameter sshPublicKeyName cannot be empty") 58 } 59 urlPath = strings.ReplaceAll(urlPath, "{sshPublicKeyName}", url.PathEscape(sshPublicKeyName)) 60 if client.subscriptionID == "" { 61 return nil, errors.New("parameter client.subscriptionID cannot be empty") 62 } 63 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 64 req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 65 if err != nil { 66 return nil, err 67 } 68 req.Telemetry(telemetryInfo) 69 reqQP := req.URL.Query() 70 reqQP.Set("api-version", "2021-03-01") 71 req.URL.RawQuery = reqQP.Encode() 72 req.Header.Set("Accept", "application/json") 73 return req, req.MarshalAsJSON(parameters) 74} 75 76// createHandleResponse handles the Create response. 77func (client *SSHPublicKeysClient) createHandleResponse(resp *azcore.Response) (SSHPublicKeyResourceResponse, error) { 78 var val *SSHPublicKeyResource 79 if err := resp.UnmarshalAsJSON(&val); err != nil { 80 return SSHPublicKeyResourceResponse{}, err 81 } 82 return SSHPublicKeyResourceResponse{RawResponse: resp.Response, SSHPublicKeyResource: val}, nil 83} 84 85// createHandleError handles the Create error response. 86func (client *SSHPublicKeysClient) createHandleError(resp *azcore.Response) error { 87 body, err := resp.Payload() 88 if err != nil { 89 return azcore.NewResponseError(err, resp.Response) 90 } 91 if len(body) == 0 { 92 return azcore.NewResponseError(errors.New(resp.Status), resp.Response) 93 } 94 return azcore.NewResponseError(errors.New(string(body)), resp.Response) 95} 96 97// Delete - Delete an SSH public key. 98// If the operation fails it returns a generic error. 99func (client *SSHPublicKeysClient) Delete(ctx context.Context, resourceGroupName string, sshPublicKeyName string, options *SSHPublicKeysDeleteOptions) (*http.Response, error) { 100 req, err := client.deleteCreateRequest(ctx, resourceGroupName, sshPublicKeyName, options) 101 if err != nil { 102 return nil, err 103 } 104 resp, err := client.con.Pipeline().Do(req) 105 if err != nil { 106 return nil, err 107 } 108 if !resp.HasStatusCode(http.StatusOK, http.StatusNoContent) { 109 return nil, client.deleteHandleError(resp) 110 } 111 return resp.Response, nil 112} 113 114// deleteCreateRequest creates the Delete request. 115func (client *SSHPublicKeysClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, sshPublicKeyName string, options *SSHPublicKeysDeleteOptions) (*azcore.Request, error) { 116 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/sshPublicKeys/{sshPublicKeyName}" 117 if resourceGroupName == "" { 118 return nil, errors.New("parameter resourceGroupName cannot be empty") 119 } 120 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 121 if sshPublicKeyName == "" { 122 return nil, errors.New("parameter sshPublicKeyName cannot be empty") 123 } 124 urlPath = strings.ReplaceAll(urlPath, "{sshPublicKeyName}", url.PathEscape(sshPublicKeyName)) 125 if client.subscriptionID == "" { 126 return nil, errors.New("parameter client.subscriptionID cannot be empty") 127 } 128 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 129 req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 130 if err != nil { 131 return nil, err 132 } 133 req.Telemetry(telemetryInfo) 134 reqQP := req.URL.Query() 135 reqQP.Set("api-version", "2021-03-01") 136 req.URL.RawQuery = reqQP.Encode() 137 return req, nil 138} 139 140// deleteHandleError handles the Delete error response. 141func (client *SSHPublicKeysClient) deleteHandleError(resp *azcore.Response) error { 142 body, err := resp.Payload() 143 if err != nil { 144 return azcore.NewResponseError(err, resp.Response) 145 } 146 if len(body) == 0 { 147 return azcore.NewResponseError(errors.New(resp.Status), resp.Response) 148 } 149 return azcore.NewResponseError(errors.New(string(body)), resp.Response) 150} 151 152// GenerateKeyPair - Generates and returns a public/private key pair and populates the SSH public key resource with the public key. The length of the key 153// will be 3072 bits. This operation can only be performed once per 154// SSH public key resource. 155// If the operation fails it returns a generic error. 156func (client *SSHPublicKeysClient) GenerateKeyPair(ctx context.Context, resourceGroupName string, sshPublicKeyName string, options *SSHPublicKeysGenerateKeyPairOptions) (SSHPublicKeyGenerateKeyPairResultResponse, error) { 157 req, err := client.generateKeyPairCreateRequest(ctx, resourceGroupName, sshPublicKeyName, options) 158 if err != nil { 159 return SSHPublicKeyGenerateKeyPairResultResponse{}, err 160 } 161 resp, err := client.con.Pipeline().Do(req) 162 if err != nil { 163 return SSHPublicKeyGenerateKeyPairResultResponse{}, err 164 } 165 if !resp.HasStatusCode(http.StatusOK) { 166 return SSHPublicKeyGenerateKeyPairResultResponse{}, client.generateKeyPairHandleError(resp) 167 } 168 return client.generateKeyPairHandleResponse(resp) 169} 170 171// generateKeyPairCreateRequest creates the GenerateKeyPair request. 172func (client *SSHPublicKeysClient) generateKeyPairCreateRequest(ctx context.Context, resourceGroupName string, sshPublicKeyName string, options *SSHPublicKeysGenerateKeyPairOptions) (*azcore.Request, error) { 173 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/sshPublicKeys/{sshPublicKeyName}/generateKeyPair" 174 if resourceGroupName == "" { 175 return nil, errors.New("parameter resourceGroupName cannot be empty") 176 } 177 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 178 if sshPublicKeyName == "" { 179 return nil, errors.New("parameter sshPublicKeyName cannot be empty") 180 } 181 urlPath = strings.ReplaceAll(urlPath, "{sshPublicKeyName}", url.PathEscape(sshPublicKeyName)) 182 if client.subscriptionID == "" { 183 return nil, errors.New("parameter client.subscriptionID cannot be empty") 184 } 185 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 186 req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 187 if err != nil { 188 return nil, err 189 } 190 req.Telemetry(telemetryInfo) 191 reqQP := req.URL.Query() 192 reqQP.Set("api-version", "2021-03-01") 193 req.URL.RawQuery = reqQP.Encode() 194 req.Header.Set("Accept", "application/json") 195 return req, nil 196} 197 198// generateKeyPairHandleResponse handles the GenerateKeyPair response. 199func (client *SSHPublicKeysClient) generateKeyPairHandleResponse(resp *azcore.Response) (SSHPublicKeyGenerateKeyPairResultResponse, error) { 200 var val *SSHPublicKeyGenerateKeyPairResult 201 if err := resp.UnmarshalAsJSON(&val); err != nil { 202 return SSHPublicKeyGenerateKeyPairResultResponse{}, err 203 } 204 return SSHPublicKeyGenerateKeyPairResultResponse{RawResponse: resp.Response, SSHPublicKeyGenerateKeyPairResult: val}, nil 205} 206 207// generateKeyPairHandleError handles the GenerateKeyPair error response. 208func (client *SSHPublicKeysClient) generateKeyPairHandleError(resp *azcore.Response) error { 209 body, err := resp.Payload() 210 if err != nil { 211 return azcore.NewResponseError(err, resp.Response) 212 } 213 if len(body) == 0 { 214 return azcore.NewResponseError(errors.New(resp.Status), resp.Response) 215 } 216 return azcore.NewResponseError(errors.New(string(body)), resp.Response) 217} 218 219// Get - Retrieves information about an SSH public key. 220// If the operation fails it returns a generic error. 221func (client *SSHPublicKeysClient) Get(ctx context.Context, resourceGroupName string, sshPublicKeyName string, options *SSHPublicKeysGetOptions) (SSHPublicKeyResourceResponse, error) { 222 req, err := client.getCreateRequest(ctx, resourceGroupName, sshPublicKeyName, options) 223 if err != nil { 224 return SSHPublicKeyResourceResponse{}, err 225 } 226 resp, err := client.con.Pipeline().Do(req) 227 if err != nil { 228 return SSHPublicKeyResourceResponse{}, err 229 } 230 if !resp.HasStatusCode(http.StatusOK) { 231 return SSHPublicKeyResourceResponse{}, client.getHandleError(resp) 232 } 233 return client.getHandleResponse(resp) 234} 235 236// getCreateRequest creates the Get request. 237func (client *SSHPublicKeysClient) getCreateRequest(ctx context.Context, resourceGroupName string, sshPublicKeyName string, options *SSHPublicKeysGetOptions) (*azcore.Request, error) { 238 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/sshPublicKeys/{sshPublicKeyName}" 239 if resourceGroupName == "" { 240 return nil, errors.New("parameter resourceGroupName cannot be empty") 241 } 242 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 243 if sshPublicKeyName == "" { 244 return nil, errors.New("parameter sshPublicKeyName cannot be empty") 245 } 246 urlPath = strings.ReplaceAll(urlPath, "{sshPublicKeyName}", url.PathEscape(sshPublicKeyName)) 247 if client.subscriptionID == "" { 248 return nil, errors.New("parameter client.subscriptionID cannot be empty") 249 } 250 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 251 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 252 if err != nil { 253 return nil, err 254 } 255 req.Telemetry(telemetryInfo) 256 reqQP := req.URL.Query() 257 reqQP.Set("api-version", "2021-03-01") 258 req.URL.RawQuery = reqQP.Encode() 259 req.Header.Set("Accept", "application/json") 260 return req, nil 261} 262 263// getHandleResponse handles the Get response. 264func (client *SSHPublicKeysClient) getHandleResponse(resp *azcore.Response) (SSHPublicKeyResourceResponse, error) { 265 var val *SSHPublicKeyResource 266 if err := resp.UnmarshalAsJSON(&val); err != nil { 267 return SSHPublicKeyResourceResponse{}, err 268 } 269 return SSHPublicKeyResourceResponse{RawResponse: resp.Response, SSHPublicKeyResource: val}, nil 270} 271 272// getHandleError handles the Get error response. 273func (client *SSHPublicKeysClient) getHandleError(resp *azcore.Response) error { 274 body, err := resp.Payload() 275 if err != nil { 276 return azcore.NewResponseError(err, resp.Response) 277 } 278 if len(body) == 0 { 279 return azcore.NewResponseError(errors.New(resp.Status), resp.Response) 280 } 281 return azcore.NewResponseError(errors.New(string(body)), resp.Response) 282} 283 284// ListByResourceGroup - Lists all of the SSH public keys in the specified resource group. Use the nextLink property in the response to get the next page 285// of SSH public keys. 286// If the operation fails it returns a generic error. 287func (client *SSHPublicKeysClient) ListByResourceGroup(resourceGroupName string, options *SSHPublicKeysListByResourceGroupOptions) SSHPublicKeysGroupListResultPager { 288 return &sshPublicKeysGroupListResultPager{ 289 pipeline: client.con.Pipeline(), 290 requester: func(ctx context.Context) (*azcore.Request, error) { 291 return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options) 292 }, 293 responder: client.listByResourceGroupHandleResponse, 294 errorer: client.listByResourceGroupHandleError, 295 advancer: func(ctx context.Context, resp SSHPublicKeysGroupListResultResponse) (*azcore.Request, error) { 296 return azcore.NewRequest(ctx, http.MethodGet, *resp.SSHPublicKeysGroupListResult.NextLink) 297 }, 298 statusCodes: []int{http.StatusOK}, 299 } 300} 301 302// listByResourceGroupCreateRequest creates the ListByResourceGroup request. 303func (client *SSHPublicKeysClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *SSHPublicKeysListByResourceGroupOptions) (*azcore.Request, error) { 304 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/sshPublicKeys" 305 if resourceGroupName == "" { 306 return nil, errors.New("parameter resourceGroupName cannot be empty") 307 } 308 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 309 if client.subscriptionID == "" { 310 return nil, errors.New("parameter client.subscriptionID cannot be empty") 311 } 312 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 313 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 314 if err != nil { 315 return nil, err 316 } 317 req.Telemetry(telemetryInfo) 318 reqQP := req.URL.Query() 319 reqQP.Set("api-version", "2021-03-01") 320 req.URL.RawQuery = reqQP.Encode() 321 req.Header.Set("Accept", "application/json") 322 return req, nil 323} 324 325// listByResourceGroupHandleResponse handles the ListByResourceGroup response. 326func (client *SSHPublicKeysClient) listByResourceGroupHandleResponse(resp *azcore.Response) (SSHPublicKeysGroupListResultResponse, error) { 327 var val *SSHPublicKeysGroupListResult 328 if err := resp.UnmarshalAsJSON(&val); err != nil { 329 return SSHPublicKeysGroupListResultResponse{}, err 330 } 331 return SSHPublicKeysGroupListResultResponse{RawResponse: resp.Response, SSHPublicKeysGroupListResult: val}, nil 332} 333 334// listByResourceGroupHandleError handles the ListByResourceGroup error response. 335func (client *SSHPublicKeysClient) listByResourceGroupHandleError(resp *azcore.Response) error { 336 body, err := resp.Payload() 337 if err != nil { 338 return azcore.NewResponseError(err, resp.Response) 339 } 340 if len(body) == 0 { 341 return azcore.NewResponseError(errors.New(resp.Status), resp.Response) 342 } 343 return azcore.NewResponseError(errors.New(string(body)), resp.Response) 344} 345 346// ListBySubscription - Lists all of the SSH public keys in the subscription. Use the nextLink property in the response to get the next page of SSH public 347// keys. 348// If the operation fails it returns a generic error. 349func (client *SSHPublicKeysClient) ListBySubscription(options *SSHPublicKeysListBySubscriptionOptions) SSHPublicKeysGroupListResultPager { 350 return &sshPublicKeysGroupListResultPager{ 351 pipeline: client.con.Pipeline(), 352 requester: func(ctx context.Context) (*azcore.Request, error) { 353 return client.listBySubscriptionCreateRequest(ctx, options) 354 }, 355 responder: client.listBySubscriptionHandleResponse, 356 errorer: client.listBySubscriptionHandleError, 357 advancer: func(ctx context.Context, resp SSHPublicKeysGroupListResultResponse) (*azcore.Request, error) { 358 return azcore.NewRequest(ctx, http.MethodGet, *resp.SSHPublicKeysGroupListResult.NextLink) 359 }, 360 statusCodes: []int{http.StatusOK}, 361 } 362} 363 364// listBySubscriptionCreateRequest creates the ListBySubscription request. 365func (client *SSHPublicKeysClient) listBySubscriptionCreateRequest(ctx context.Context, options *SSHPublicKeysListBySubscriptionOptions) (*azcore.Request, error) { 366 urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Compute/sshPublicKeys" 367 if client.subscriptionID == "" { 368 return nil, errors.New("parameter client.subscriptionID cannot be empty") 369 } 370 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 371 req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 372 if err != nil { 373 return nil, err 374 } 375 req.Telemetry(telemetryInfo) 376 reqQP := req.URL.Query() 377 reqQP.Set("api-version", "2021-03-01") 378 req.URL.RawQuery = reqQP.Encode() 379 req.Header.Set("Accept", "application/json") 380 return req, nil 381} 382 383// listBySubscriptionHandleResponse handles the ListBySubscription response. 384func (client *SSHPublicKeysClient) listBySubscriptionHandleResponse(resp *azcore.Response) (SSHPublicKeysGroupListResultResponse, error) { 385 var val *SSHPublicKeysGroupListResult 386 if err := resp.UnmarshalAsJSON(&val); err != nil { 387 return SSHPublicKeysGroupListResultResponse{}, err 388 } 389 return SSHPublicKeysGroupListResultResponse{RawResponse: resp.Response, SSHPublicKeysGroupListResult: val}, nil 390} 391 392// listBySubscriptionHandleError handles the ListBySubscription error response. 393func (client *SSHPublicKeysClient) listBySubscriptionHandleError(resp *azcore.Response) error { 394 body, err := resp.Payload() 395 if err != nil { 396 return azcore.NewResponseError(err, resp.Response) 397 } 398 if len(body) == 0 { 399 return azcore.NewResponseError(errors.New(resp.Status), resp.Response) 400 } 401 return azcore.NewResponseError(errors.New(string(body)), resp.Response) 402} 403 404// Update - Updates a new SSH public key resource. 405// If the operation fails it returns a generic error. 406func (client *SSHPublicKeysClient) Update(ctx context.Context, resourceGroupName string, sshPublicKeyName string, parameters SSHPublicKeyUpdateResource, options *SSHPublicKeysUpdateOptions) (SSHPublicKeyResourceResponse, error) { 407 req, err := client.updateCreateRequest(ctx, resourceGroupName, sshPublicKeyName, parameters, options) 408 if err != nil { 409 return SSHPublicKeyResourceResponse{}, err 410 } 411 resp, err := client.con.Pipeline().Do(req) 412 if err != nil { 413 return SSHPublicKeyResourceResponse{}, err 414 } 415 if !resp.HasStatusCode(http.StatusOK) { 416 return SSHPublicKeyResourceResponse{}, client.updateHandleError(resp) 417 } 418 return client.updateHandleResponse(resp) 419} 420 421// updateCreateRequest creates the Update request. 422func (client *SSHPublicKeysClient) updateCreateRequest(ctx context.Context, resourceGroupName string, sshPublicKeyName string, parameters SSHPublicKeyUpdateResource, options *SSHPublicKeysUpdateOptions) (*azcore.Request, error) { 423 urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/sshPublicKeys/{sshPublicKeyName}" 424 if resourceGroupName == "" { 425 return nil, errors.New("parameter resourceGroupName cannot be empty") 426 } 427 urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) 428 if sshPublicKeyName == "" { 429 return nil, errors.New("parameter sshPublicKeyName cannot be empty") 430 } 431 urlPath = strings.ReplaceAll(urlPath, "{sshPublicKeyName}", url.PathEscape(sshPublicKeyName)) 432 if client.subscriptionID == "" { 433 return nil, errors.New("parameter client.subscriptionID cannot be empty") 434 } 435 urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) 436 req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath)) 437 if err != nil { 438 return nil, err 439 } 440 req.Telemetry(telemetryInfo) 441 reqQP := req.URL.Query() 442 reqQP.Set("api-version", "2021-03-01") 443 req.URL.RawQuery = reqQP.Encode() 444 req.Header.Set("Accept", "application/json") 445 return req, req.MarshalAsJSON(parameters) 446} 447 448// updateHandleResponse handles the Update response. 449func (client *SSHPublicKeysClient) updateHandleResponse(resp *azcore.Response) (SSHPublicKeyResourceResponse, error) { 450 var val *SSHPublicKeyResource 451 if err := resp.UnmarshalAsJSON(&val); err != nil { 452 return SSHPublicKeyResourceResponse{}, err 453 } 454 return SSHPublicKeyResourceResponse{RawResponse: resp.Response, SSHPublicKeyResource: val}, nil 455} 456 457// updateHandleError handles the Update error response. 458func (client *SSHPublicKeysClient) updateHandleError(resp *azcore.Response) error { 459 body, err := resp.Payload() 460 if err != nil { 461 return azcore.NewResponseError(err, resp.Response) 462 } 463 if len(body) == 0 { 464 return azcore.NewResponseError(errors.New(resp.Status), resp.Response) 465 } 466 return azcore.NewResponseError(errors.New(string(body)), resp.Response) 467} 468