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