1package compute
2
3// Copyright (c) Microsoft and contributors.  All rights reserved.
4//
5// Licensed under the Apache License, Version 2.0 (the "License");
6// you may not use this file except in compliance with the License.
7// You may obtain a copy of the License at
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13//
14// See the License for the specific language governing permissions and
15// limitations under the License.
16//
17// Code generated by Microsoft (R) AutoRest Code Generator.
18// Changes may cause incorrect behavior and will be lost if the code is regenerated.
19
20import (
21	"context"
22	"github.com/Azure/go-autorest/autorest"
23	"github.com/Azure/go-autorest/autorest/azure"
24	"github.com/Azure/go-autorest/tracing"
25	"net/http"
26)
27
28// ProximityPlacementGroupsClient is the compute Client
29type ProximityPlacementGroupsClient struct {
30	BaseClient
31}
32
33// NewProximityPlacementGroupsClient creates an instance of the ProximityPlacementGroupsClient client.
34func NewProximityPlacementGroupsClient(subscriptionID string) ProximityPlacementGroupsClient {
35	return NewProximityPlacementGroupsClientWithBaseURI(DefaultBaseURI, subscriptionID)
36}
37
38// NewProximityPlacementGroupsClientWithBaseURI creates an instance of the ProximityPlacementGroupsClient client using
39// a custom endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
40// clouds, Azure stack).
41func NewProximityPlacementGroupsClientWithBaseURI(baseURI string, subscriptionID string) ProximityPlacementGroupsClient {
42	return ProximityPlacementGroupsClient{NewWithBaseURI(baseURI, subscriptionID)}
43}
44
45// CreateOrUpdate create or update a proximity placement group.
46// Parameters:
47// resourceGroupName - the name of the resource group.
48// proximityPlacementGroupName - the name of the proximity placement group.
49// parameters - parameters supplied to the Create Proximity Placement Group operation.
50func (client ProximityPlacementGroupsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string, parameters ProximityPlacementGroup) (result ProximityPlacementGroup, err error) {
51	if tracing.IsEnabled() {
52		ctx = tracing.StartSpan(ctx, fqdn+"/ProximityPlacementGroupsClient.CreateOrUpdate")
53		defer func() {
54			sc := -1
55			if result.Response.Response != nil {
56				sc = result.Response.Response.StatusCode
57			}
58			tracing.EndSpan(ctx, sc, err)
59		}()
60	}
61	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, proximityPlacementGroupName, parameters)
62	if err != nil {
63		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "CreateOrUpdate", nil, "Failure preparing request")
64		return
65	}
66
67	resp, err := client.CreateOrUpdateSender(req)
68	if err != nil {
69		result.Response = autorest.Response{Response: resp}
70		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "CreateOrUpdate", resp, "Failure sending request")
71		return
72	}
73
74	result, err = client.CreateOrUpdateResponder(resp)
75	if err != nil {
76		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "CreateOrUpdate", resp, "Failure responding to request")
77	}
78
79	return
80}
81
82// CreateOrUpdatePreparer prepares the CreateOrUpdate request.
83func (client ProximityPlacementGroupsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string, parameters ProximityPlacementGroup) (*http.Request, error) {
84	pathParameters := map[string]interface{}{
85		"proximityPlacementGroupName": autorest.Encode("path", proximityPlacementGroupName),
86		"resourceGroupName":           autorest.Encode("path", resourceGroupName),
87		"subscriptionId":              autorest.Encode("path", client.SubscriptionID),
88	}
89
90	const APIVersion = "2019-12-01"
91	queryParameters := map[string]interface{}{
92		"api-version": APIVersion,
93	}
94
95	preparer := autorest.CreatePreparer(
96		autorest.AsContentType("application/json; charset=utf-8"),
97		autorest.AsPut(),
98		autorest.WithBaseURL(client.BaseURI),
99		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/proximityPlacementGroups/{proximityPlacementGroupName}", pathParameters),
100		autorest.WithJSON(parameters),
101		autorest.WithQueryParameters(queryParameters))
102	return preparer.Prepare((&http.Request{}).WithContext(ctx))
103}
104
105// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
106// http.Response Body if it receives an error.
107func (client ProximityPlacementGroupsClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) {
108	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
109}
110
111// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
112// closes the http.Response Body.
113func (client ProximityPlacementGroupsClient) CreateOrUpdateResponder(resp *http.Response) (result ProximityPlacementGroup, err error) {
114	err = autorest.Respond(
115		resp,
116		client.ByInspecting(),
117		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
118		autorest.ByUnmarshallingJSON(&result),
119		autorest.ByClosing())
120	result.Response = autorest.Response{Response: resp}
121	return
122}
123
124// Delete delete a proximity placement group.
125// Parameters:
126// resourceGroupName - the name of the resource group.
127// proximityPlacementGroupName - the name of the proximity placement group.
128func (client ProximityPlacementGroupsClient) Delete(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string) (result autorest.Response, err error) {
129	if tracing.IsEnabled() {
130		ctx = tracing.StartSpan(ctx, fqdn+"/ProximityPlacementGroupsClient.Delete")
131		defer func() {
132			sc := -1
133			if result.Response != nil {
134				sc = result.Response.StatusCode
135			}
136			tracing.EndSpan(ctx, sc, err)
137		}()
138	}
139	req, err := client.DeletePreparer(ctx, resourceGroupName, proximityPlacementGroupName)
140	if err != nil {
141		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Delete", nil, "Failure preparing request")
142		return
143	}
144
145	resp, err := client.DeleteSender(req)
146	if err != nil {
147		result.Response = resp
148		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Delete", resp, "Failure sending request")
149		return
150	}
151
152	result, err = client.DeleteResponder(resp)
153	if err != nil {
154		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Delete", resp, "Failure responding to request")
155	}
156
157	return
158}
159
160// DeletePreparer prepares the Delete request.
161func (client ProximityPlacementGroupsClient) DeletePreparer(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string) (*http.Request, error) {
162	pathParameters := map[string]interface{}{
163		"proximityPlacementGroupName": autorest.Encode("path", proximityPlacementGroupName),
164		"resourceGroupName":           autorest.Encode("path", resourceGroupName),
165		"subscriptionId":              autorest.Encode("path", client.SubscriptionID),
166	}
167
168	const APIVersion = "2019-12-01"
169	queryParameters := map[string]interface{}{
170		"api-version": APIVersion,
171	}
172
173	preparer := autorest.CreatePreparer(
174		autorest.AsDelete(),
175		autorest.WithBaseURL(client.BaseURI),
176		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/proximityPlacementGroups/{proximityPlacementGroupName}", pathParameters),
177		autorest.WithQueryParameters(queryParameters))
178	return preparer.Prepare((&http.Request{}).WithContext(ctx))
179}
180
181// DeleteSender sends the Delete request. The method will close the
182// http.Response Body if it receives an error.
183func (client ProximityPlacementGroupsClient) DeleteSender(req *http.Request) (*http.Response, error) {
184	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
185}
186
187// DeleteResponder handles the response to the Delete request. The method always
188// closes the http.Response Body.
189func (client ProximityPlacementGroupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
190	err = autorest.Respond(
191		resp,
192		client.ByInspecting(),
193		azure.WithErrorUnlessStatusCode(http.StatusOK),
194		autorest.ByClosing())
195	result.Response = resp
196	return
197}
198
199// Get retrieves information about a proximity placement group .
200// Parameters:
201// resourceGroupName - the name of the resource group.
202// proximityPlacementGroupName - the name of the proximity placement group.
203// includeColocationStatus - includeColocationStatus=true enables fetching the colocation status of all the
204// resources in the proximity placement group.
205func (client ProximityPlacementGroupsClient) Get(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string, includeColocationStatus string) (result ProximityPlacementGroup, err error) {
206	if tracing.IsEnabled() {
207		ctx = tracing.StartSpan(ctx, fqdn+"/ProximityPlacementGroupsClient.Get")
208		defer func() {
209			sc := -1
210			if result.Response.Response != nil {
211				sc = result.Response.Response.StatusCode
212			}
213			tracing.EndSpan(ctx, sc, err)
214		}()
215	}
216	req, err := client.GetPreparer(ctx, resourceGroupName, proximityPlacementGroupName, includeColocationStatus)
217	if err != nil {
218		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Get", nil, "Failure preparing request")
219		return
220	}
221
222	resp, err := client.GetSender(req)
223	if err != nil {
224		result.Response = autorest.Response{Response: resp}
225		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Get", resp, "Failure sending request")
226		return
227	}
228
229	result, err = client.GetResponder(resp)
230	if err != nil {
231		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Get", resp, "Failure responding to request")
232	}
233
234	return
235}
236
237// GetPreparer prepares the Get request.
238func (client ProximityPlacementGroupsClient) GetPreparer(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string, includeColocationStatus string) (*http.Request, error) {
239	pathParameters := map[string]interface{}{
240		"proximityPlacementGroupName": autorest.Encode("path", proximityPlacementGroupName),
241		"resourceGroupName":           autorest.Encode("path", resourceGroupName),
242		"subscriptionId":              autorest.Encode("path", client.SubscriptionID),
243	}
244
245	const APIVersion = "2019-12-01"
246	queryParameters := map[string]interface{}{
247		"api-version": APIVersion,
248	}
249	if len(includeColocationStatus) > 0 {
250		queryParameters["includeColocationStatus"] = autorest.Encode("query", includeColocationStatus)
251	}
252
253	preparer := autorest.CreatePreparer(
254		autorest.AsGet(),
255		autorest.WithBaseURL(client.BaseURI),
256		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/proximityPlacementGroups/{proximityPlacementGroupName}", pathParameters),
257		autorest.WithQueryParameters(queryParameters))
258	return preparer.Prepare((&http.Request{}).WithContext(ctx))
259}
260
261// GetSender sends the Get request. The method will close the
262// http.Response Body if it receives an error.
263func (client ProximityPlacementGroupsClient) GetSender(req *http.Request) (*http.Response, error) {
264	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
265}
266
267// GetResponder handles the response to the Get request. The method always
268// closes the http.Response Body.
269func (client ProximityPlacementGroupsClient) GetResponder(resp *http.Response) (result ProximityPlacementGroup, err error) {
270	err = autorest.Respond(
271		resp,
272		client.ByInspecting(),
273		azure.WithErrorUnlessStatusCode(http.StatusOK),
274		autorest.ByUnmarshallingJSON(&result),
275		autorest.ByClosing())
276	result.Response = autorest.Response{Response: resp}
277	return
278}
279
280// ListByResourceGroup lists all proximity placement groups in a resource group.
281// Parameters:
282// resourceGroupName - the name of the resource group.
283func (client ProximityPlacementGroupsClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ProximityPlacementGroupListResultPage, err error) {
284	if tracing.IsEnabled() {
285		ctx = tracing.StartSpan(ctx, fqdn+"/ProximityPlacementGroupsClient.ListByResourceGroup")
286		defer func() {
287			sc := -1
288			if result.ppglr.Response.Response != nil {
289				sc = result.ppglr.Response.Response.StatusCode
290			}
291			tracing.EndSpan(ctx, sc, err)
292		}()
293	}
294	result.fn = client.listByResourceGroupNextResults
295	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
296	if err != nil {
297		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "ListByResourceGroup", nil, "Failure preparing request")
298		return
299	}
300
301	resp, err := client.ListByResourceGroupSender(req)
302	if err != nil {
303		result.ppglr.Response = autorest.Response{Response: resp}
304		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "ListByResourceGroup", resp, "Failure sending request")
305		return
306	}
307
308	result.ppglr, err = client.ListByResourceGroupResponder(resp)
309	if err != nil {
310		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "ListByResourceGroup", resp, "Failure responding to request")
311	}
312
313	return
314}
315
316// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
317func (client ProximityPlacementGroupsClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
318	pathParameters := map[string]interface{}{
319		"resourceGroupName": autorest.Encode("path", resourceGroupName),
320		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
321	}
322
323	const APIVersion = "2019-12-01"
324	queryParameters := map[string]interface{}{
325		"api-version": APIVersion,
326	}
327
328	preparer := autorest.CreatePreparer(
329		autorest.AsGet(),
330		autorest.WithBaseURL(client.BaseURI),
331		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/proximityPlacementGroups", pathParameters),
332		autorest.WithQueryParameters(queryParameters))
333	return preparer.Prepare((&http.Request{}).WithContext(ctx))
334}
335
336// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
337// http.Response Body if it receives an error.
338func (client ProximityPlacementGroupsClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
339	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
340}
341
342// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
343// closes the http.Response Body.
344func (client ProximityPlacementGroupsClient) ListByResourceGroupResponder(resp *http.Response) (result ProximityPlacementGroupListResult, err error) {
345	err = autorest.Respond(
346		resp,
347		client.ByInspecting(),
348		azure.WithErrorUnlessStatusCode(http.StatusOK),
349		autorest.ByUnmarshallingJSON(&result),
350		autorest.ByClosing())
351	result.Response = autorest.Response{Response: resp}
352	return
353}
354
355// listByResourceGroupNextResults retrieves the next set of results, if any.
356func (client ProximityPlacementGroupsClient) listByResourceGroupNextResults(ctx context.Context, lastResults ProximityPlacementGroupListResult) (result ProximityPlacementGroupListResult, err error) {
357	req, err := lastResults.proximityPlacementGroupListResultPreparer(ctx)
358	if err != nil {
359		return result, autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
360	}
361	if req == nil {
362		return
363	}
364	resp, err := client.ListByResourceGroupSender(req)
365	if err != nil {
366		result.Response = autorest.Response{Response: resp}
367		return result, autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
368	}
369	result, err = client.ListByResourceGroupResponder(resp)
370	if err != nil {
371		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
372	}
373	return
374}
375
376// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
377func (client ProximityPlacementGroupsClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ProximityPlacementGroupListResultIterator, err error) {
378	if tracing.IsEnabled() {
379		ctx = tracing.StartSpan(ctx, fqdn+"/ProximityPlacementGroupsClient.ListByResourceGroup")
380		defer func() {
381			sc := -1
382			if result.Response().Response.Response != nil {
383				sc = result.page.Response().Response.Response.StatusCode
384			}
385			tracing.EndSpan(ctx, sc, err)
386		}()
387	}
388	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
389	return
390}
391
392// ListBySubscription lists all proximity placement groups in a subscription.
393func (client ProximityPlacementGroupsClient) ListBySubscription(ctx context.Context) (result ProximityPlacementGroupListResultPage, err error) {
394	if tracing.IsEnabled() {
395		ctx = tracing.StartSpan(ctx, fqdn+"/ProximityPlacementGroupsClient.ListBySubscription")
396		defer func() {
397			sc := -1
398			if result.ppglr.Response.Response != nil {
399				sc = result.ppglr.Response.Response.StatusCode
400			}
401			tracing.EndSpan(ctx, sc, err)
402		}()
403	}
404	result.fn = client.listBySubscriptionNextResults
405	req, err := client.ListBySubscriptionPreparer(ctx)
406	if err != nil {
407		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "ListBySubscription", nil, "Failure preparing request")
408		return
409	}
410
411	resp, err := client.ListBySubscriptionSender(req)
412	if err != nil {
413		result.ppglr.Response = autorest.Response{Response: resp}
414		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "ListBySubscription", resp, "Failure sending request")
415		return
416	}
417
418	result.ppglr, err = client.ListBySubscriptionResponder(resp)
419	if err != nil {
420		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "ListBySubscription", resp, "Failure responding to request")
421	}
422
423	return
424}
425
426// ListBySubscriptionPreparer prepares the ListBySubscription request.
427func (client ProximityPlacementGroupsClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) {
428	pathParameters := map[string]interface{}{
429		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
430	}
431
432	const APIVersion = "2019-12-01"
433	queryParameters := map[string]interface{}{
434		"api-version": APIVersion,
435	}
436
437	preparer := autorest.CreatePreparer(
438		autorest.AsGet(),
439		autorest.WithBaseURL(client.BaseURI),
440		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Compute/proximityPlacementGroups", pathParameters),
441		autorest.WithQueryParameters(queryParameters))
442	return preparer.Prepare((&http.Request{}).WithContext(ctx))
443}
444
445// ListBySubscriptionSender sends the ListBySubscription request. The method will close the
446// http.Response Body if it receives an error.
447func (client ProximityPlacementGroupsClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
448	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
449}
450
451// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
452// closes the http.Response Body.
453func (client ProximityPlacementGroupsClient) ListBySubscriptionResponder(resp *http.Response) (result ProximityPlacementGroupListResult, err error) {
454	err = autorest.Respond(
455		resp,
456		client.ByInspecting(),
457		azure.WithErrorUnlessStatusCode(http.StatusOK),
458		autorest.ByUnmarshallingJSON(&result),
459		autorest.ByClosing())
460	result.Response = autorest.Response{Response: resp}
461	return
462}
463
464// listBySubscriptionNextResults retrieves the next set of results, if any.
465func (client ProximityPlacementGroupsClient) listBySubscriptionNextResults(ctx context.Context, lastResults ProximityPlacementGroupListResult) (result ProximityPlacementGroupListResult, err error) {
466	req, err := lastResults.proximityPlacementGroupListResultPreparer(ctx)
467	if err != nil {
468		return result, autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
469	}
470	if req == nil {
471		return
472	}
473	resp, err := client.ListBySubscriptionSender(req)
474	if err != nil {
475		result.Response = autorest.Response{Response: resp}
476		return result, autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
477	}
478	result, err = client.ListBySubscriptionResponder(resp)
479	if err != nil {
480		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
481	}
482	return
483}
484
485// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
486func (client ProximityPlacementGroupsClient) ListBySubscriptionComplete(ctx context.Context) (result ProximityPlacementGroupListResultIterator, err error) {
487	if tracing.IsEnabled() {
488		ctx = tracing.StartSpan(ctx, fqdn+"/ProximityPlacementGroupsClient.ListBySubscription")
489		defer func() {
490			sc := -1
491			if result.Response().Response.Response != nil {
492				sc = result.page.Response().Response.Response.StatusCode
493			}
494			tracing.EndSpan(ctx, sc, err)
495		}()
496	}
497	result.page, err = client.ListBySubscription(ctx)
498	return
499}
500
501// Update update a proximity placement group.
502// Parameters:
503// resourceGroupName - the name of the resource group.
504// proximityPlacementGroupName - the name of the proximity placement group.
505// parameters - parameters supplied to the Update Proximity Placement Group operation.
506func (client ProximityPlacementGroupsClient) Update(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string, parameters ProximityPlacementGroupUpdate) (result ProximityPlacementGroup, err error) {
507	if tracing.IsEnabled() {
508		ctx = tracing.StartSpan(ctx, fqdn+"/ProximityPlacementGroupsClient.Update")
509		defer func() {
510			sc := -1
511			if result.Response.Response != nil {
512				sc = result.Response.Response.StatusCode
513			}
514			tracing.EndSpan(ctx, sc, err)
515		}()
516	}
517	req, err := client.UpdatePreparer(ctx, resourceGroupName, proximityPlacementGroupName, parameters)
518	if err != nil {
519		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Update", nil, "Failure preparing request")
520		return
521	}
522
523	resp, err := client.UpdateSender(req)
524	if err != nil {
525		result.Response = autorest.Response{Response: resp}
526		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Update", resp, "Failure sending request")
527		return
528	}
529
530	result, err = client.UpdateResponder(resp)
531	if err != nil {
532		err = autorest.NewErrorWithError(err, "compute.ProximityPlacementGroupsClient", "Update", resp, "Failure responding to request")
533	}
534
535	return
536}
537
538// UpdatePreparer prepares the Update request.
539func (client ProximityPlacementGroupsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, proximityPlacementGroupName string, parameters ProximityPlacementGroupUpdate) (*http.Request, error) {
540	pathParameters := map[string]interface{}{
541		"proximityPlacementGroupName": autorest.Encode("path", proximityPlacementGroupName),
542		"resourceGroupName":           autorest.Encode("path", resourceGroupName),
543		"subscriptionId":              autorest.Encode("path", client.SubscriptionID),
544	}
545
546	const APIVersion = "2019-12-01"
547	queryParameters := map[string]interface{}{
548		"api-version": APIVersion,
549	}
550
551	preparer := autorest.CreatePreparer(
552		autorest.AsContentType("application/json; charset=utf-8"),
553		autorest.AsPatch(),
554		autorest.WithBaseURL(client.BaseURI),
555		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/proximityPlacementGroups/{proximityPlacementGroupName}", pathParameters),
556		autorest.WithJSON(parameters),
557		autorest.WithQueryParameters(queryParameters))
558	return preparer.Prepare((&http.Request{}).WithContext(ctx))
559}
560
561// UpdateSender sends the Update request. The method will close the
562// http.Response Body if it receives an error.
563func (client ProximityPlacementGroupsClient) UpdateSender(req *http.Request) (*http.Response, error) {
564	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
565}
566
567// UpdateResponder handles the response to the Update request. The method always
568// closes the http.Response Body.
569func (client ProximityPlacementGroupsClient) UpdateResponder(resp *http.Response) (result ProximityPlacementGroup, err error) {
570	err = autorest.Respond(
571		resp,
572		client.ByInspecting(),
573		azure.WithErrorUnlessStatusCode(http.StatusOK),
574		autorest.ByUnmarshallingJSON(&result),
575		autorest.ByClosing())
576	result.Response = autorest.Response{Response: resp}
577	return
578}
579