1 package compute
2
3
4
5
6
7
8
9 import (
10 "context"
11 "github.com/Azure/go-autorest/autorest"
12 "github.com/Azure/go-autorest/autorest/azure"
13 "github.com/Azure/go-autorest/tracing"
14 "net/http"
15 )
16
17
18 type VirtualMachineExtensionsClient struct {
19 BaseClient
20 }
21
22
23 func NewVirtualMachineExtensionsClient(subscriptionID string) VirtualMachineExtensionsClient {
24 return NewVirtualMachineExtensionsClientWithBaseURI(DefaultBaseURI, subscriptionID)
25 }
26
27
28
29
30 func NewVirtualMachineExtensionsClientWithBaseURI(baseURI string, subscriptionID string) VirtualMachineExtensionsClient {
31 return VirtualMachineExtensionsClient{NewWithBaseURI(baseURI, subscriptionID)}
32 }
33
34
35
36
37
38
39
40 func (client VirtualMachineExtensionsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters VirtualMachineExtension) (result VirtualMachineExtensionsCreateOrUpdateFuture, err error) {
41 if tracing.IsEnabled() {
42 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.CreateOrUpdate")
43 defer func() {
44 sc := -1
45 if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
46 sc = result.FutureAPI.Response().StatusCode
47 }
48 tracing.EndSpan(ctx, sc, err)
49 }()
50 }
51 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, VMName, VMExtensionName, extensionParameters)
52 if err != nil {
53 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "CreateOrUpdate", nil, "Failure preparing request")
54 return
55 }
56
57 result, err = client.CreateOrUpdateSender(req)
58 if err != nil {
59 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "CreateOrUpdate", result.Response(), "Failure sending request")
60 return
61 }
62
63 return
64 }
65
66
67 func (client VirtualMachineExtensionsClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters VirtualMachineExtension) (*http.Request, error) {
68 pathParameters := map[string]interface{}{
69 "resourceGroupName": autorest.Encode("path", resourceGroupName),
70 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
71 "vmExtensionName": autorest.Encode("path", VMExtensionName),
72 "vmName": autorest.Encode("path", VMName),
73 }
74
75 const APIVersion = "2020-06-01"
76 queryParameters := map[string]interface{}{
77 "api-version": APIVersion,
78 }
79
80 preparer := autorest.CreatePreparer(
81 autorest.AsContentType("application/json; charset=utf-8"),
82 autorest.AsPut(),
83 autorest.WithBaseURL(client.BaseURI),
84 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{vmExtensionName}", pathParameters),
85 autorest.WithJSON(extensionParameters),
86 autorest.WithQueryParameters(queryParameters))
87 return preparer.Prepare((&http.Request{}).WithContext(ctx))
88 }
89
90
91
92 func (client VirtualMachineExtensionsClient) CreateOrUpdateSender(req *http.Request) (future VirtualMachineExtensionsCreateOrUpdateFuture, err error) {
93 var resp *http.Response
94 future.FutureAPI = &azure.Future{}
95 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
96 if err != nil {
97 return
98 }
99 var azf azure.Future
100 azf, err = azure.NewFutureFromResponse(resp)
101 future.FutureAPI = &azf
102 future.Result = future.result
103 return
104 }
105
106
107
108 func (client VirtualMachineExtensionsClient) CreateOrUpdateResponder(resp *http.Response) (result VirtualMachineExtension, err error) {
109 err = autorest.Respond(
110 resp,
111 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
112 autorest.ByUnmarshallingJSON(&result),
113 autorest.ByClosing())
114 result.Response = autorest.Response{Response: resp}
115 return
116 }
117
118
119
120
121
122
123 func (client VirtualMachineExtensionsClient) Delete(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string) (result VirtualMachineExtensionsDeleteFuture, err error) {
124 if tracing.IsEnabled() {
125 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.Delete")
126 defer func() {
127 sc := -1
128 if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
129 sc = result.FutureAPI.Response().StatusCode
130 }
131 tracing.EndSpan(ctx, sc, err)
132 }()
133 }
134 req, err := client.DeletePreparer(ctx, resourceGroupName, VMName, VMExtensionName)
135 if err != nil {
136 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Delete", nil, "Failure preparing request")
137 return
138 }
139
140 result, err = client.DeleteSender(req)
141 if err != nil {
142 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Delete", result.Response(), "Failure sending request")
143 return
144 }
145
146 return
147 }
148
149
150 func (client VirtualMachineExtensionsClient) DeletePreparer(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string) (*http.Request, error) {
151 pathParameters := map[string]interface{}{
152 "resourceGroupName": autorest.Encode("path", resourceGroupName),
153 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
154 "vmExtensionName": autorest.Encode("path", VMExtensionName),
155 "vmName": autorest.Encode("path", VMName),
156 }
157
158 const APIVersion = "2020-06-01"
159 queryParameters := map[string]interface{}{
160 "api-version": APIVersion,
161 }
162
163 preparer := autorest.CreatePreparer(
164 autorest.AsDelete(),
165 autorest.WithBaseURL(client.BaseURI),
166 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{vmExtensionName}", pathParameters),
167 autorest.WithQueryParameters(queryParameters))
168 return preparer.Prepare((&http.Request{}).WithContext(ctx))
169 }
170
171
172
173 func (client VirtualMachineExtensionsClient) DeleteSender(req *http.Request) (future VirtualMachineExtensionsDeleteFuture, err error) {
174 var resp *http.Response
175 future.FutureAPI = &azure.Future{}
176 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
177 if err != nil {
178 return
179 }
180 var azf azure.Future
181 azf, err = azure.NewFutureFromResponse(resp)
182 future.FutureAPI = &azf
183 future.Result = future.result
184 return
185 }
186
187
188
189 func (client VirtualMachineExtensionsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
190 err = autorest.Respond(
191 resp,
192 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
193 autorest.ByClosing())
194 result.Response = resp
195 return
196 }
197
198
199
200
201
202
203
204 func (client VirtualMachineExtensionsClient) Get(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, expand string) (result VirtualMachineExtension, err error) {
205 if tracing.IsEnabled() {
206 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.Get")
207 defer func() {
208 sc := -1
209 if result.Response.Response != nil {
210 sc = result.Response.Response.StatusCode
211 }
212 tracing.EndSpan(ctx, sc, err)
213 }()
214 }
215 req, err := client.GetPreparer(ctx, resourceGroupName, VMName, VMExtensionName, expand)
216 if err != nil {
217 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Get", nil, "Failure preparing request")
218 return
219 }
220
221 resp, err := client.GetSender(req)
222 if err != nil {
223 result.Response = autorest.Response{Response: resp}
224 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Get", resp, "Failure sending request")
225 return
226 }
227
228 result, err = client.GetResponder(resp)
229 if err != nil {
230 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Get", resp, "Failure responding to request")
231 return
232 }
233
234 return
235 }
236
237
238 func (client VirtualMachineExtensionsClient) GetPreparer(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, expand string) (*http.Request, error) {
239 pathParameters := map[string]interface{}{
240 "resourceGroupName": autorest.Encode("path", resourceGroupName),
241 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
242 "vmExtensionName": autorest.Encode("path", VMExtensionName),
243 "vmName": autorest.Encode("path", VMName),
244 }
245
246 const APIVersion = "2020-06-01"
247 queryParameters := map[string]interface{}{
248 "api-version": APIVersion,
249 }
250 if len(expand) > 0 {
251 queryParameters["$expand"] = autorest.Encode("query", expand)
252 }
253
254 preparer := autorest.CreatePreparer(
255 autorest.AsGet(),
256 autorest.WithBaseURL(client.BaseURI),
257 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{vmExtensionName}", pathParameters),
258 autorest.WithQueryParameters(queryParameters))
259 return preparer.Prepare((&http.Request{}).WithContext(ctx))
260 }
261
262
263
264 func (client VirtualMachineExtensionsClient) GetSender(req *http.Request) (*http.Response, error) {
265 return client.Send(req, azure.DoRetryWithRegistration(client.Client))
266 }
267
268
269
270 func (client VirtualMachineExtensionsClient) GetResponder(resp *http.Response) (result VirtualMachineExtension, err error) {
271 err = autorest.Respond(
272 resp,
273 azure.WithErrorUnlessStatusCode(http.StatusOK),
274 autorest.ByUnmarshallingJSON(&result),
275 autorest.ByClosing())
276 result.Response = autorest.Response{Response: resp}
277 return
278 }
279
280
281
282
283
284
285 func (client VirtualMachineExtensionsClient) List(ctx context.Context, resourceGroupName string, VMName string, expand string) (result VirtualMachineExtensionsListResult, err error) {
286 if tracing.IsEnabled() {
287 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.List")
288 defer func() {
289 sc := -1
290 if result.Response.Response != nil {
291 sc = result.Response.Response.StatusCode
292 }
293 tracing.EndSpan(ctx, sc, err)
294 }()
295 }
296 req, err := client.ListPreparer(ctx, resourceGroupName, VMName, expand)
297 if err != nil {
298 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "List", nil, "Failure preparing request")
299 return
300 }
301
302 resp, err := client.ListSender(req)
303 if err != nil {
304 result.Response = autorest.Response{Response: resp}
305 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "List", resp, "Failure sending request")
306 return
307 }
308
309 result, err = client.ListResponder(resp)
310 if err != nil {
311 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "List", resp, "Failure responding to request")
312 return
313 }
314
315 return
316 }
317
318
319 func (client VirtualMachineExtensionsClient) ListPreparer(ctx context.Context, resourceGroupName string, VMName string, expand string) (*http.Request, error) {
320 pathParameters := map[string]interface{}{
321 "resourceGroupName": autorest.Encode("path", resourceGroupName),
322 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
323 "vmName": autorest.Encode("path", VMName),
324 }
325
326 const APIVersion = "2020-06-01"
327 queryParameters := map[string]interface{}{
328 "api-version": APIVersion,
329 }
330 if len(expand) > 0 {
331 queryParameters["$expand"] = autorest.Encode("query", expand)
332 }
333
334 preparer := autorest.CreatePreparer(
335 autorest.AsGet(),
336 autorest.WithBaseURL(client.BaseURI),
337 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions", pathParameters),
338 autorest.WithQueryParameters(queryParameters))
339 return preparer.Prepare((&http.Request{}).WithContext(ctx))
340 }
341
342
343
344 func (client VirtualMachineExtensionsClient) ListSender(req *http.Request) (*http.Response, error) {
345 return client.Send(req, azure.DoRetryWithRegistration(client.Client))
346 }
347
348
349
350 func (client VirtualMachineExtensionsClient) ListResponder(resp *http.Response) (result VirtualMachineExtensionsListResult, err error) {
351 err = autorest.Respond(
352 resp,
353 azure.WithErrorUnlessStatusCode(http.StatusOK),
354 autorest.ByUnmarshallingJSON(&result),
355 autorest.ByClosing())
356 result.Response = autorest.Response{Response: resp}
357 return
358 }
359
360
361
362
363
364
365
366 func (client VirtualMachineExtensionsClient) Update(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters VirtualMachineExtensionUpdate) (result VirtualMachineExtensionsUpdateFuture, err error) {
367 if tracing.IsEnabled() {
368 ctx = tracing.StartSpan(ctx, fqdn+"/VirtualMachineExtensionsClient.Update")
369 defer func() {
370 sc := -1
371 if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
372 sc = result.FutureAPI.Response().StatusCode
373 }
374 tracing.EndSpan(ctx, sc, err)
375 }()
376 }
377 req, err := client.UpdatePreparer(ctx, resourceGroupName, VMName, VMExtensionName, extensionParameters)
378 if err != nil {
379 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Update", nil, "Failure preparing request")
380 return
381 }
382
383 result, err = client.UpdateSender(req)
384 if err != nil {
385 err = autorest.NewErrorWithError(err, "compute.VirtualMachineExtensionsClient", "Update", result.Response(), "Failure sending request")
386 return
387 }
388
389 return
390 }
391
392
393 func (client VirtualMachineExtensionsClient) UpdatePreparer(ctx context.Context, resourceGroupName string, VMName string, VMExtensionName string, extensionParameters VirtualMachineExtensionUpdate) (*http.Request, error) {
394 pathParameters := map[string]interface{}{
395 "resourceGroupName": autorest.Encode("path", resourceGroupName),
396 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
397 "vmExtensionName": autorest.Encode("path", VMExtensionName),
398 "vmName": autorest.Encode("path", VMName),
399 }
400
401 const APIVersion = "2020-06-01"
402 queryParameters := map[string]interface{}{
403 "api-version": APIVersion,
404 }
405
406 preparer := autorest.CreatePreparer(
407 autorest.AsContentType("application/json; charset=utf-8"),
408 autorest.AsPatch(),
409 autorest.WithBaseURL(client.BaseURI),
410 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{vmExtensionName}", pathParameters),
411 autorest.WithJSON(extensionParameters),
412 autorest.WithQueryParameters(queryParameters))
413 return preparer.Prepare((&http.Request{}).WithContext(ctx))
414 }
415
416
417
418 func (client VirtualMachineExtensionsClient) UpdateSender(req *http.Request) (future VirtualMachineExtensionsUpdateFuture, err error) {
419 var resp *http.Response
420 future.FutureAPI = &azure.Future{}
421 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
422 if err != nil {
423 return
424 }
425 var azf azure.Future
426 azf, err = azure.NewFutureFromResponse(resp)
427 future.FutureAPI = &azf
428 future.Result = future.result
429 return
430 }
431
432
433
434 func (client VirtualMachineExtensionsClient) UpdateResponder(resp *http.Response) (result VirtualMachineExtension, err error) {
435 err = autorest.Respond(
436 resp,
437 azure.WithErrorUnlessStatusCode(http.StatusOK),
438 autorest.ByUnmarshallingJSON(&result),
439 autorest.ByClosing())
440 result.Response = autorest.Response{Response: resp}
441 return
442 }
443
View as plain text