1package kusto 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/autorest/validation" 25 "github.com/Azure/go-autorest/tracing" 26 "net/http" 27) 28 29// ClustersClient is the the Azure Kusto management API provides a RESTful set of web services that interact with Azure 30// Kusto services to manage your clusters and databases. The API enables you to create, update, and delete clusters and 31// databases. 32type ClustersClient struct { 33 BaseClient 34} 35 36// NewClustersClient creates an instance of the ClustersClient client. 37func NewClustersClient(subscriptionID string) ClustersClient { 38 return NewClustersClientWithBaseURI(DefaultBaseURI, subscriptionID) 39} 40 41// NewClustersClientWithBaseURI creates an instance of the ClustersClient client using a custom endpoint. Use this 42// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 43func NewClustersClientWithBaseURI(baseURI string, subscriptionID string) ClustersClient { 44 return ClustersClient{NewWithBaseURI(baseURI, subscriptionID)} 45} 46 47// CheckNameAvailability checks that the cluster name is valid and is not already in use. 48// Parameters: 49// location - azure location. 50// clusterName - the name of the cluster. 51func (client ClustersClient) CheckNameAvailability(ctx context.Context, location string, clusterName ClusterCheckNameRequest) (result CheckNameResult, err error) { 52 if tracing.IsEnabled() { 53 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.CheckNameAvailability") 54 defer func() { 55 sc := -1 56 if result.Response.Response != nil { 57 sc = result.Response.Response.StatusCode 58 } 59 tracing.EndSpan(ctx, sc, err) 60 }() 61 } 62 if err := validation.Validate([]validation.Validation{ 63 {TargetValue: clusterName, 64 Constraints: []validation.Constraint{{Target: "clusterName.Name", Name: validation.Null, Rule: true, Chain: nil}, 65 {Target: "clusterName.Type", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 66 return result, validation.NewError("kusto.ClustersClient", "CheckNameAvailability", err.Error()) 67 } 68 69 req, err := client.CheckNameAvailabilityPreparer(ctx, location, clusterName) 70 if err != nil { 71 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "CheckNameAvailability", nil, "Failure preparing request") 72 return 73 } 74 75 resp, err := client.CheckNameAvailabilitySender(req) 76 if err != nil { 77 result.Response = autorest.Response{Response: resp} 78 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "CheckNameAvailability", resp, "Failure sending request") 79 return 80 } 81 82 result, err = client.CheckNameAvailabilityResponder(resp) 83 if err != nil { 84 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "CheckNameAvailability", resp, "Failure responding to request") 85 return 86 } 87 88 return 89} 90 91// CheckNameAvailabilityPreparer prepares the CheckNameAvailability request. 92func (client ClustersClient) CheckNameAvailabilityPreparer(ctx context.Context, location string, clusterName ClusterCheckNameRequest) (*http.Request, error) { 93 pathParameters := map[string]interface{}{ 94 "location": autorest.Encode("path", location), 95 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 96 } 97 98 const APIVersion = "2019-11-09" 99 queryParameters := map[string]interface{}{ 100 "api-version": APIVersion, 101 } 102 103 preparer := autorest.CreatePreparer( 104 autorest.AsContentType("application/json; charset=utf-8"), 105 autorest.AsPost(), 106 autorest.WithBaseURL(client.BaseURI), 107 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Kusto/locations/{location}/checkNameAvailability", pathParameters), 108 autorest.WithJSON(clusterName), 109 autorest.WithQueryParameters(queryParameters)) 110 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 111} 112 113// CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the 114// http.Response Body if it receives an error. 115func (client ClustersClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { 116 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 117} 118 119// CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always 120// closes the http.Response Body. 121func (client ClustersClient) CheckNameAvailabilityResponder(resp *http.Response) (result CheckNameResult, err error) { 122 err = autorest.Respond( 123 resp, 124 azure.WithErrorUnlessStatusCode(http.StatusOK), 125 autorest.ByUnmarshallingJSON(&result), 126 autorest.ByClosing()) 127 result.Response = autorest.Response{Response: resp} 128 return 129} 130 131// CreateOrUpdate create or update a Kusto cluster. 132// Parameters: 133// resourceGroupName - the name of the resource group containing the Kusto cluster. 134// clusterName - the name of the Kusto cluster. 135// parameters - the Kusto cluster parameters supplied to the CreateOrUpdate operation. 136func (client ClustersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, clusterName string, parameters Cluster) (result ClustersCreateOrUpdateFuture, err error) { 137 if tracing.IsEnabled() { 138 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.CreateOrUpdate") 139 defer func() { 140 sc := -1 141 if result.Response() != nil { 142 sc = result.Response().StatusCode 143 } 144 tracing.EndSpan(ctx, sc, err) 145 }() 146 } 147 if err := validation.Validate([]validation.Validation{ 148 {TargetValue: parameters, 149 Constraints: []validation.Constraint{{Target: "parameters.Sku", Name: validation.Null, Rule: true, Chain: nil}, 150 {Target: "parameters.ClusterProperties", Name: validation.Null, Rule: false, 151 Chain: []validation.Constraint{{Target: "parameters.ClusterProperties.OptimizedAutoscale", Name: validation.Null, Rule: false, 152 Chain: []validation.Constraint{{Target: "parameters.ClusterProperties.OptimizedAutoscale.Version", Name: validation.Null, Rule: true, Chain: nil}, 153 {Target: "parameters.ClusterProperties.OptimizedAutoscale.IsEnabled", Name: validation.Null, Rule: true, Chain: nil}, 154 {Target: "parameters.ClusterProperties.OptimizedAutoscale.Minimum", Name: validation.Null, Rule: true, Chain: nil}, 155 {Target: "parameters.ClusterProperties.OptimizedAutoscale.Maximum", Name: validation.Null, Rule: true, Chain: nil}, 156 }}, 157 {Target: "parameters.ClusterProperties.VirtualNetworkConfiguration", Name: validation.Null, Rule: false, 158 Chain: []validation.Constraint{{Target: "parameters.ClusterProperties.VirtualNetworkConfiguration.SubnetID", Name: validation.Null, Rule: true, Chain: nil}, 159 {Target: "parameters.ClusterProperties.VirtualNetworkConfiguration.EnginePublicIPID", Name: validation.Null, Rule: true, Chain: nil}, 160 {Target: "parameters.ClusterProperties.VirtualNetworkConfiguration.DataManagementPublicIPID", Name: validation.Null, Rule: true, Chain: nil}, 161 }}, 162 {Target: "parameters.ClusterProperties.KeyVaultProperties", Name: validation.Null, Rule: false, 163 Chain: []validation.Constraint{{Target: "parameters.ClusterProperties.KeyVaultProperties.KeyName", Name: validation.Null, Rule: true, Chain: nil}, 164 {Target: "parameters.ClusterProperties.KeyVaultProperties.KeyVersion", Name: validation.Null, Rule: true, Chain: nil}, 165 {Target: "parameters.ClusterProperties.KeyVaultProperties.KeyVaultURI", Name: validation.Null, Rule: true, Chain: nil}, 166 }}, 167 }}}}}); err != nil { 168 return result, validation.NewError("kusto.ClustersClient", "CreateOrUpdate", err.Error()) 169 } 170 171 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, clusterName, parameters) 172 if err != nil { 173 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "CreateOrUpdate", nil, "Failure preparing request") 174 return 175 } 176 177 result, err = client.CreateOrUpdateSender(req) 178 if err != nil { 179 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "CreateOrUpdate", nil, "Failure sending request") 180 return 181 } 182 183 return 184} 185 186// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 187func (client ClustersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, parameters Cluster) (*http.Request, error) { 188 pathParameters := map[string]interface{}{ 189 "clusterName": autorest.Encode("path", clusterName), 190 "resourceGroupName": autorest.Encode("path", resourceGroupName), 191 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 192 } 193 194 const APIVersion = "2019-11-09" 195 queryParameters := map[string]interface{}{ 196 "api-version": APIVersion, 197 } 198 199 preparer := autorest.CreatePreparer( 200 autorest.AsContentType("application/json; charset=utf-8"), 201 autorest.AsPut(), 202 autorest.WithBaseURL(client.BaseURI), 203 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}", pathParameters), 204 autorest.WithJSON(parameters), 205 autorest.WithQueryParameters(queryParameters)) 206 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 207} 208 209// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 210// http.Response Body if it receives an error. 211func (client ClustersClient) CreateOrUpdateSender(req *http.Request) (future ClustersCreateOrUpdateFuture, err error) { 212 var resp *http.Response 213 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 214 if err != nil { 215 return 216 } 217 var azf azure.Future 218 azf, err = azure.NewFutureFromResponse(resp) 219 future.FutureAPI = &azf 220 future.Result = func(client ClustersClient) (c Cluster, err error) { 221 var done bool 222 done, err = future.DoneWithContext(context.Background(), client) 223 if err != nil { 224 err = autorest.NewErrorWithError(err, "kusto.ClustersCreateOrUpdateFuture", "Result", future.Response(), "Polling failure") 225 return 226 } 227 if !done { 228 err = azure.NewAsyncOpIncompleteError("kusto.ClustersCreateOrUpdateFuture") 229 return 230 } 231 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 232 if c.Response.Response, err = future.GetResult(sender); err == nil && c.Response.Response.StatusCode != http.StatusNoContent { 233 c, err = client.CreateOrUpdateResponder(c.Response.Response) 234 if err != nil { 235 err = autorest.NewErrorWithError(err, "kusto.ClustersCreateOrUpdateFuture", "Result", c.Response.Response, "Failure responding to request") 236 } 237 } 238 return 239 } 240 return 241} 242 243// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 244// closes the http.Response Body. 245func (client ClustersClient) CreateOrUpdateResponder(resp *http.Response) (result Cluster, err error) { 246 err = autorest.Respond( 247 resp, 248 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 249 autorest.ByUnmarshallingJSON(&result), 250 autorest.ByClosing()) 251 result.Response = autorest.Response{Response: resp} 252 return 253} 254 255// Delete deletes a Kusto cluster. 256// Parameters: 257// resourceGroupName - the name of the resource group containing the Kusto cluster. 258// clusterName - the name of the Kusto cluster. 259func (client ClustersClient) Delete(ctx context.Context, resourceGroupName string, clusterName string) (result ClustersDeleteFuture, err error) { 260 if tracing.IsEnabled() { 261 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.Delete") 262 defer func() { 263 sc := -1 264 if result.Response() != nil { 265 sc = result.Response().StatusCode 266 } 267 tracing.EndSpan(ctx, sc, err) 268 }() 269 } 270 req, err := client.DeletePreparer(ctx, resourceGroupName, clusterName) 271 if err != nil { 272 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Delete", nil, "Failure preparing request") 273 return 274 } 275 276 result, err = client.DeleteSender(req) 277 if err != nil { 278 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Delete", nil, "Failure sending request") 279 return 280 } 281 282 return 283} 284 285// DeletePreparer prepares the Delete request. 286func (client ClustersClient) DeletePreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 287 pathParameters := map[string]interface{}{ 288 "clusterName": autorest.Encode("path", clusterName), 289 "resourceGroupName": autorest.Encode("path", resourceGroupName), 290 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 291 } 292 293 const APIVersion = "2019-11-09" 294 queryParameters := map[string]interface{}{ 295 "api-version": APIVersion, 296 } 297 298 preparer := autorest.CreatePreparer( 299 autorest.AsDelete(), 300 autorest.WithBaseURL(client.BaseURI), 301 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}", pathParameters), 302 autorest.WithQueryParameters(queryParameters)) 303 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 304} 305 306// DeleteSender sends the Delete request. The method will close the 307// http.Response Body if it receives an error. 308func (client ClustersClient) DeleteSender(req *http.Request) (future ClustersDeleteFuture, err error) { 309 var resp *http.Response 310 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 311 if err != nil { 312 return 313 } 314 var azf azure.Future 315 azf, err = azure.NewFutureFromResponse(resp) 316 future.FutureAPI = &azf 317 future.Result = func(client ClustersClient) (ar autorest.Response, err error) { 318 var done bool 319 done, err = future.DoneWithContext(context.Background(), client) 320 if err != nil { 321 err = autorest.NewErrorWithError(err, "kusto.ClustersDeleteFuture", "Result", future.Response(), "Polling failure") 322 return 323 } 324 if !done { 325 err = azure.NewAsyncOpIncompleteError("kusto.ClustersDeleteFuture") 326 return 327 } 328 ar.Response = future.Response() 329 return 330 } 331 return 332} 333 334// DeleteResponder handles the response to the Delete request. The method always 335// closes the http.Response Body. 336func (client ClustersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 337 err = autorest.Respond( 338 resp, 339 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 340 autorest.ByClosing()) 341 result.Response = resp 342 return 343} 344 345// DetachFollowerDatabases detaches all followers of a database owned by this cluster. 346// Parameters: 347// resourceGroupName - the name of the resource group containing the Kusto cluster. 348// clusterName - the name of the Kusto cluster. 349// followerDatabaseToRemove - the follower databases properties to remove. 350func (client ClustersClient) DetachFollowerDatabases(ctx context.Context, resourceGroupName string, clusterName string, followerDatabaseToRemove FollowerDatabaseDefinition) (result ClustersDetachFollowerDatabasesFuture, err error) { 351 if tracing.IsEnabled() { 352 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.DetachFollowerDatabases") 353 defer func() { 354 sc := -1 355 if result.Response() != nil { 356 sc = result.Response().StatusCode 357 } 358 tracing.EndSpan(ctx, sc, err) 359 }() 360 } 361 if err := validation.Validate([]validation.Validation{ 362 {TargetValue: followerDatabaseToRemove, 363 Constraints: []validation.Constraint{{Target: "followerDatabaseToRemove.ClusterResourceID", Name: validation.Null, Rule: true, Chain: nil}, 364 {Target: "followerDatabaseToRemove.AttachedDatabaseConfigurationName", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 365 return result, validation.NewError("kusto.ClustersClient", "DetachFollowerDatabases", err.Error()) 366 } 367 368 req, err := client.DetachFollowerDatabasesPreparer(ctx, resourceGroupName, clusterName, followerDatabaseToRemove) 369 if err != nil { 370 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "DetachFollowerDatabases", nil, "Failure preparing request") 371 return 372 } 373 374 result, err = client.DetachFollowerDatabasesSender(req) 375 if err != nil { 376 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "DetachFollowerDatabases", nil, "Failure sending request") 377 return 378 } 379 380 return 381} 382 383// DetachFollowerDatabasesPreparer prepares the DetachFollowerDatabases request. 384func (client ClustersClient) DetachFollowerDatabasesPreparer(ctx context.Context, resourceGroupName string, clusterName string, followerDatabaseToRemove FollowerDatabaseDefinition) (*http.Request, error) { 385 pathParameters := map[string]interface{}{ 386 "clusterName": autorest.Encode("path", clusterName), 387 "resourceGroupName": autorest.Encode("path", resourceGroupName), 388 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 389 } 390 391 const APIVersion = "2019-11-09" 392 queryParameters := map[string]interface{}{ 393 "api-version": APIVersion, 394 } 395 396 followerDatabaseToRemove.DatabaseName = nil 397 preparer := autorest.CreatePreparer( 398 autorest.AsContentType("application/json; charset=utf-8"), 399 autorest.AsPost(), 400 autorest.WithBaseURL(client.BaseURI), 401 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/detachFollowerDatabases", pathParameters), 402 autorest.WithJSON(followerDatabaseToRemove), 403 autorest.WithQueryParameters(queryParameters)) 404 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 405} 406 407// DetachFollowerDatabasesSender sends the DetachFollowerDatabases request. The method will close the 408// http.Response Body if it receives an error. 409func (client ClustersClient) DetachFollowerDatabasesSender(req *http.Request) (future ClustersDetachFollowerDatabasesFuture, err error) { 410 var resp *http.Response 411 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 412 if err != nil { 413 return 414 } 415 var azf azure.Future 416 azf, err = azure.NewFutureFromResponse(resp) 417 future.FutureAPI = &azf 418 future.Result = func(client ClustersClient) (ar autorest.Response, err error) { 419 var done bool 420 done, err = future.DoneWithContext(context.Background(), client) 421 if err != nil { 422 err = autorest.NewErrorWithError(err, "kusto.ClustersDetachFollowerDatabasesFuture", "Result", future.Response(), "Polling failure") 423 return 424 } 425 if !done { 426 err = azure.NewAsyncOpIncompleteError("kusto.ClustersDetachFollowerDatabasesFuture") 427 return 428 } 429 ar.Response = future.Response() 430 return 431 } 432 return 433} 434 435// DetachFollowerDatabasesResponder handles the response to the DetachFollowerDatabases request. The method always 436// closes the http.Response Body. 437func (client ClustersClient) DetachFollowerDatabasesResponder(resp *http.Response) (result autorest.Response, err error) { 438 err = autorest.Respond( 439 resp, 440 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 441 autorest.ByClosing()) 442 result.Response = resp 443 return 444} 445 446// DiagnoseVirtualNetwork diagnoses network connectivity status for external resources on which the service is 447// dependent on. 448// Parameters: 449// resourceGroupName - the name of the resource group containing the Kusto cluster. 450// clusterName - the name of the Kusto cluster. 451func (client ClustersClient) DiagnoseVirtualNetwork(ctx context.Context, resourceGroupName string, clusterName string) (result ClustersDiagnoseVirtualNetworkFuture, err error) { 452 if tracing.IsEnabled() { 453 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.DiagnoseVirtualNetwork") 454 defer func() { 455 sc := -1 456 if result.Response() != nil { 457 sc = result.Response().StatusCode 458 } 459 tracing.EndSpan(ctx, sc, err) 460 }() 461 } 462 req, err := client.DiagnoseVirtualNetworkPreparer(ctx, resourceGroupName, clusterName) 463 if err != nil { 464 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "DiagnoseVirtualNetwork", nil, "Failure preparing request") 465 return 466 } 467 468 result, err = client.DiagnoseVirtualNetworkSender(req) 469 if err != nil { 470 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "DiagnoseVirtualNetwork", nil, "Failure sending request") 471 return 472 } 473 474 return 475} 476 477// DiagnoseVirtualNetworkPreparer prepares the DiagnoseVirtualNetwork request. 478func (client ClustersClient) DiagnoseVirtualNetworkPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 479 pathParameters := map[string]interface{}{ 480 "clusterName": autorest.Encode("path", clusterName), 481 "resourceGroupName": autorest.Encode("path", resourceGroupName), 482 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 483 } 484 485 const APIVersion = "2019-11-09" 486 queryParameters := map[string]interface{}{ 487 "api-version": APIVersion, 488 } 489 490 preparer := autorest.CreatePreparer( 491 autorest.AsPost(), 492 autorest.WithBaseURL(client.BaseURI), 493 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/diagnoseVirtualNetwork", pathParameters), 494 autorest.WithQueryParameters(queryParameters)) 495 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 496} 497 498// DiagnoseVirtualNetworkSender sends the DiagnoseVirtualNetwork request. The method will close the 499// http.Response Body if it receives an error. 500func (client ClustersClient) DiagnoseVirtualNetworkSender(req *http.Request) (future ClustersDiagnoseVirtualNetworkFuture, err error) { 501 var resp *http.Response 502 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 503 if err != nil { 504 return 505 } 506 var azf azure.Future 507 azf, err = azure.NewFutureFromResponse(resp) 508 future.FutureAPI = &azf 509 future.Result = func(client ClustersClient) (dvnr DiagnoseVirtualNetworkResult, err error) { 510 var done bool 511 done, err = future.DoneWithContext(context.Background(), client) 512 if err != nil { 513 err = autorest.NewErrorWithError(err, "kusto.ClustersDiagnoseVirtualNetworkFuture", "Result", future.Response(), "Polling failure") 514 return 515 } 516 if !done { 517 err = azure.NewAsyncOpIncompleteError("kusto.ClustersDiagnoseVirtualNetworkFuture") 518 return 519 } 520 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 521 if dvnr.Response.Response, err = future.GetResult(sender); err == nil && dvnr.Response.Response.StatusCode != http.StatusNoContent { 522 dvnr, err = client.DiagnoseVirtualNetworkResponder(dvnr.Response.Response) 523 if err != nil { 524 err = autorest.NewErrorWithError(err, "kusto.ClustersDiagnoseVirtualNetworkFuture", "Result", dvnr.Response.Response, "Failure responding to request") 525 } 526 } 527 return 528 } 529 return 530} 531 532// DiagnoseVirtualNetworkResponder handles the response to the DiagnoseVirtualNetwork request. The method always 533// closes the http.Response Body. 534func (client ClustersClient) DiagnoseVirtualNetworkResponder(resp *http.Response) (result DiagnoseVirtualNetworkResult, err error) { 535 err = autorest.Respond( 536 resp, 537 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 538 autorest.ByUnmarshallingJSON(&result), 539 autorest.ByClosing()) 540 result.Response = autorest.Response{Response: resp} 541 return 542} 543 544// Get gets a Kusto cluster. 545// Parameters: 546// resourceGroupName - the name of the resource group containing the Kusto cluster. 547// clusterName - the name of the Kusto cluster. 548func (client ClustersClient) Get(ctx context.Context, resourceGroupName string, clusterName string) (result Cluster, err error) { 549 if tracing.IsEnabled() { 550 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.Get") 551 defer func() { 552 sc := -1 553 if result.Response.Response != nil { 554 sc = result.Response.Response.StatusCode 555 } 556 tracing.EndSpan(ctx, sc, err) 557 }() 558 } 559 req, err := client.GetPreparer(ctx, resourceGroupName, clusterName) 560 if err != nil { 561 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Get", nil, "Failure preparing request") 562 return 563 } 564 565 resp, err := client.GetSender(req) 566 if err != nil { 567 result.Response = autorest.Response{Response: resp} 568 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Get", resp, "Failure sending request") 569 return 570 } 571 572 result, err = client.GetResponder(resp) 573 if err != nil { 574 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Get", resp, "Failure responding to request") 575 return 576 } 577 578 return 579} 580 581// GetPreparer prepares the Get request. 582func (client ClustersClient) GetPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 583 pathParameters := map[string]interface{}{ 584 "clusterName": autorest.Encode("path", clusterName), 585 "resourceGroupName": autorest.Encode("path", resourceGroupName), 586 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 587 } 588 589 const APIVersion = "2019-11-09" 590 queryParameters := map[string]interface{}{ 591 "api-version": APIVersion, 592 } 593 594 preparer := autorest.CreatePreparer( 595 autorest.AsGet(), 596 autorest.WithBaseURL(client.BaseURI), 597 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}", pathParameters), 598 autorest.WithQueryParameters(queryParameters)) 599 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 600} 601 602// GetSender sends the Get request. The method will close the 603// http.Response Body if it receives an error. 604func (client ClustersClient) GetSender(req *http.Request) (*http.Response, error) { 605 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 606} 607 608// GetResponder handles the response to the Get request. The method always 609// closes the http.Response Body. 610func (client ClustersClient) GetResponder(resp *http.Response) (result Cluster, err error) { 611 err = autorest.Respond( 612 resp, 613 azure.WithErrorUnlessStatusCode(http.StatusOK), 614 autorest.ByUnmarshallingJSON(&result), 615 autorest.ByClosing()) 616 result.Response = autorest.Response{Response: resp} 617 return 618} 619 620// List lists all Kusto clusters within a subscription. 621func (client ClustersClient) List(ctx context.Context) (result ClusterListResult, err error) { 622 if tracing.IsEnabled() { 623 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.List") 624 defer func() { 625 sc := -1 626 if result.Response.Response != nil { 627 sc = result.Response.Response.StatusCode 628 } 629 tracing.EndSpan(ctx, sc, err) 630 }() 631 } 632 req, err := client.ListPreparer(ctx) 633 if err != nil { 634 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "List", nil, "Failure preparing request") 635 return 636 } 637 638 resp, err := client.ListSender(req) 639 if err != nil { 640 result.Response = autorest.Response{Response: resp} 641 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "List", resp, "Failure sending request") 642 return 643 } 644 645 result, err = client.ListResponder(resp) 646 if err != nil { 647 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "List", resp, "Failure responding to request") 648 return 649 } 650 651 return 652} 653 654// ListPreparer prepares the List request. 655func (client ClustersClient) ListPreparer(ctx context.Context) (*http.Request, error) { 656 pathParameters := map[string]interface{}{ 657 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 658 } 659 660 const APIVersion = "2019-11-09" 661 queryParameters := map[string]interface{}{ 662 "api-version": APIVersion, 663 } 664 665 preparer := autorest.CreatePreparer( 666 autorest.AsGet(), 667 autorest.WithBaseURL(client.BaseURI), 668 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Kusto/clusters", pathParameters), 669 autorest.WithQueryParameters(queryParameters)) 670 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 671} 672 673// ListSender sends the List request. The method will close the 674// http.Response Body if it receives an error. 675func (client ClustersClient) ListSender(req *http.Request) (*http.Response, error) { 676 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 677} 678 679// ListResponder handles the response to the List request. The method always 680// closes the http.Response Body. 681func (client ClustersClient) ListResponder(resp *http.Response) (result ClusterListResult, err error) { 682 err = autorest.Respond( 683 resp, 684 azure.WithErrorUnlessStatusCode(http.StatusOK), 685 autorest.ByUnmarshallingJSON(&result), 686 autorest.ByClosing()) 687 result.Response = autorest.Response{Response: resp} 688 return 689} 690 691// ListByResourceGroup lists all Kusto clusters within a resource group. 692// Parameters: 693// resourceGroupName - the name of the resource group containing the Kusto cluster. 694func (client ClustersClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ClusterListResult, err error) { 695 if tracing.IsEnabled() { 696 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.ListByResourceGroup") 697 defer func() { 698 sc := -1 699 if result.Response.Response != nil { 700 sc = result.Response.Response.StatusCode 701 } 702 tracing.EndSpan(ctx, sc, err) 703 }() 704 } 705 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 706 if err != nil { 707 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListByResourceGroup", nil, "Failure preparing request") 708 return 709 } 710 711 resp, err := client.ListByResourceGroupSender(req) 712 if err != nil { 713 result.Response = autorest.Response{Response: resp} 714 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListByResourceGroup", resp, "Failure sending request") 715 return 716 } 717 718 result, err = client.ListByResourceGroupResponder(resp) 719 if err != nil { 720 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListByResourceGroup", resp, "Failure responding to request") 721 return 722 } 723 724 return 725} 726 727// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 728func (client ClustersClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 729 pathParameters := map[string]interface{}{ 730 "resourceGroupName": autorest.Encode("path", resourceGroupName), 731 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 732 } 733 734 const APIVersion = "2019-11-09" 735 queryParameters := map[string]interface{}{ 736 "api-version": APIVersion, 737 } 738 739 preparer := autorest.CreatePreparer( 740 autorest.AsGet(), 741 autorest.WithBaseURL(client.BaseURI), 742 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters", pathParameters), 743 autorest.WithQueryParameters(queryParameters)) 744 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 745} 746 747// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 748// http.Response Body if it receives an error. 749func (client ClustersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 750 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 751} 752 753// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 754// closes the http.Response Body. 755func (client ClustersClient) ListByResourceGroupResponder(resp *http.Response) (result ClusterListResult, err error) { 756 err = autorest.Respond( 757 resp, 758 azure.WithErrorUnlessStatusCode(http.StatusOK), 759 autorest.ByUnmarshallingJSON(&result), 760 autorest.ByClosing()) 761 result.Response = autorest.Response{Response: resp} 762 return 763} 764 765// ListFollowerDatabases returns a list of databases that are owned by this cluster and were followed by another 766// cluster. 767// Parameters: 768// resourceGroupName - the name of the resource group containing the Kusto cluster. 769// clusterName - the name of the Kusto cluster. 770func (client ClustersClient) ListFollowerDatabases(ctx context.Context, resourceGroupName string, clusterName string) (result FollowerDatabaseListResult, err error) { 771 if tracing.IsEnabled() { 772 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.ListFollowerDatabases") 773 defer func() { 774 sc := -1 775 if result.Response.Response != nil { 776 sc = result.Response.Response.StatusCode 777 } 778 tracing.EndSpan(ctx, sc, err) 779 }() 780 } 781 req, err := client.ListFollowerDatabasesPreparer(ctx, resourceGroupName, clusterName) 782 if err != nil { 783 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListFollowerDatabases", nil, "Failure preparing request") 784 return 785 } 786 787 resp, err := client.ListFollowerDatabasesSender(req) 788 if err != nil { 789 result.Response = autorest.Response{Response: resp} 790 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListFollowerDatabases", resp, "Failure sending request") 791 return 792 } 793 794 result, err = client.ListFollowerDatabasesResponder(resp) 795 if err != nil { 796 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListFollowerDatabases", resp, "Failure responding to request") 797 return 798 } 799 800 return 801} 802 803// ListFollowerDatabasesPreparer prepares the ListFollowerDatabases request. 804func (client ClustersClient) ListFollowerDatabasesPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 805 pathParameters := map[string]interface{}{ 806 "clusterName": autorest.Encode("path", clusterName), 807 "resourceGroupName": autorest.Encode("path", resourceGroupName), 808 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 809 } 810 811 const APIVersion = "2019-11-09" 812 queryParameters := map[string]interface{}{ 813 "api-version": APIVersion, 814 } 815 816 preparer := autorest.CreatePreparer( 817 autorest.AsPost(), 818 autorest.WithBaseURL(client.BaseURI), 819 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/listFollowerDatabases", pathParameters), 820 autorest.WithQueryParameters(queryParameters)) 821 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 822} 823 824// ListFollowerDatabasesSender sends the ListFollowerDatabases request. The method will close the 825// http.Response Body if it receives an error. 826func (client ClustersClient) ListFollowerDatabasesSender(req *http.Request) (*http.Response, error) { 827 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 828} 829 830// ListFollowerDatabasesResponder handles the response to the ListFollowerDatabases request. The method always 831// closes the http.Response Body. 832func (client ClustersClient) ListFollowerDatabasesResponder(resp *http.Response) (result FollowerDatabaseListResult, err error) { 833 err = autorest.Respond( 834 resp, 835 azure.WithErrorUnlessStatusCode(http.StatusOK), 836 autorest.ByUnmarshallingJSON(&result), 837 autorest.ByClosing()) 838 result.Response = autorest.Response{Response: resp} 839 return 840} 841 842// ListSkus lists eligible SKUs for Kusto resource provider. 843func (client ClustersClient) ListSkus(ctx context.Context) (result SkuDescriptionList, err error) { 844 if tracing.IsEnabled() { 845 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.ListSkus") 846 defer func() { 847 sc := -1 848 if result.Response.Response != nil { 849 sc = result.Response.Response.StatusCode 850 } 851 tracing.EndSpan(ctx, sc, err) 852 }() 853 } 854 req, err := client.ListSkusPreparer(ctx) 855 if err != nil { 856 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListSkus", nil, "Failure preparing request") 857 return 858 } 859 860 resp, err := client.ListSkusSender(req) 861 if err != nil { 862 result.Response = autorest.Response{Response: resp} 863 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListSkus", resp, "Failure sending request") 864 return 865 } 866 867 result, err = client.ListSkusResponder(resp) 868 if err != nil { 869 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListSkus", resp, "Failure responding to request") 870 return 871 } 872 873 return 874} 875 876// ListSkusPreparer prepares the ListSkus request. 877func (client ClustersClient) ListSkusPreparer(ctx context.Context) (*http.Request, error) { 878 pathParameters := map[string]interface{}{ 879 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 880 } 881 882 const APIVersion = "2019-11-09" 883 queryParameters := map[string]interface{}{ 884 "api-version": APIVersion, 885 } 886 887 preparer := autorest.CreatePreparer( 888 autorest.AsGet(), 889 autorest.WithBaseURL(client.BaseURI), 890 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Kusto/skus", pathParameters), 891 autorest.WithQueryParameters(queryParameters)) 892 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 893} 894 895// ListSkusSender sends the ListSkus request. The method will close the 896// http.Response Body if it receives an error. 897func (client ClustersClient) ListSkusSender(req *http.Request) (*http.Response, error) { 898 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 899} 900 901// ListSkusResponder handles the response to the ListSkus request. The method always 902// closes the http.Response Body. 903func (client ClustersClient) ListSkusResponder(resp *http.Response) (result SkuDescriptionList, err error) { 904 err = autorest.Respond( 905 resp, 906 azure.WithErrorUnlessStatusCode(http.StatusOK), 907 autorest.ByUnmarshallingJSON(&result), 908 autorest.ByClosing()) 909 result.Response = autorest.Response{Response: resp} 910 return 911} 912 913// ListSkusByResource returns the SKUs available for the provided resource. 914// Parameters: 915// resourceGroupName - the name of the resource group containing the Kusto cluster. 916// clusterName - the name of the Kusto cluster. 917func (client ClustersClient) ListSkusByResource(ctx context.Context, resourceGroupName string, clusterName string) (result ListResourceSkusResult, err error) { 918 if tracing.IsEnabled() { 919 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.ListSkusByResource") 920 defer func() { 921 sc := -1 922 if result.Response.Response != nil { 923 sc = result.Response.Response.StatusCode 924 } 925 tracing.EndSpan(ctx, sc, err) 926 }() 927 } 928 req, err := client.ListSkusByResourcePreparer(ctx, resourceGroupName, clusterName) 929 if err != nil { 930 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListSkusByResource", nil, "Failure preparing request") 931 return 932 } 933 934 resp, err := client.ListSkusByResourceSender(req) 935 if err != nil { 936 result.Response = autorest.Response{Response: resp} 937 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListSkusByResource", resp, "Failure sending request") 938 return 939 } 940 941 result, err = client.ListSkusByResourceResponder(resp) 942 if err != nil { 943 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "ListSkusByResource", resp, "Failure responding to request") 944 return 945 } 946 947 return 948} 949 950// ListSkusByResourcePreparer prepares the ListSkusByResource request. 951func (client ClustersClient) ListSkusByResourcePreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 952 pathParameters := map[string]interface{}{ 953 "clusterName": autorest.Encode("path", clusterName), 954 "resourceGroupName": autorest.Encode("path", resourceGroupName), 955 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 956 } 957 958 const APIVersion = "2019-11-09" 959 queryParameters := map[string]interface{}{ 960 "api-version": APIVersion, 961 } 962 963 preparer := autorest.CreatePreparer( 964 autorest.AsGet(), 965 autorest.WithBaseURL(client.BaseURI), 966 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/skus", pathParameters), 967 autorest.WithQueryParameters(queryParameters)) 968 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 969} 970 971// ListSkusByResourceSender sends the ListSkusByResource request. The method will close the 972// http.Response Body if it receives an error. 973func (client ClustersClient) ListSkusByResourceSender(req *http.Request) (*http.Response, error) { 974 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 975} 976 977// ListSkusByResourceResponder handles the response to the ListSkusByResource request. The method always 978// closes the http.Response Body. 979func (client ClustersClient) ListSkusByResourceResponder(resp *http.Response) (result ListResourceSkusResult, err error) { 980 err = autorest.Respond( 981 resp, 982 azure.WithErrorUnlessStatusCode(http.StatusOK), 983 autorest.ByUnmarshallingJSON(&result), 984 autorest.ByClosing()) 985 result.Response = autorest.Response{Response: resp} 986 return 987} 988 989// Start starts a Kusto cluster. 990// Parameters: 991// resourceGroupName - the name of the resource group containing the Kusto cluster. 992// clusterName - the name of the Kusto cluster. 993func (client ClustersClient) Start(ctx context.Context, resourceGroupName string, clusterName string) (result ClustersStartFuture, err error) { 994 if tracing.IsEnabled() { 995 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.Start") 996 defer func() { 997 sc := -1 998 if result.Response() != nil { 999 sc = result.Response().StatusCode 1000 } 1001 tracing.EndSpan(ctx, sc, err) 1002 }() 1003 } 1004 req, err := client.StartPreparer(ctx, resourceGroupName, clusterName) 1005 if err != nil { 1006 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Start", nil, "Failure preparing request") 1007 return 1008 } 1009 1010 result, err = client.StartSender(req) 1011 if err != nil { 1012 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Start", nil, "Failure sending request") 1013 return 1014 } 1015 1016 return 1017} 1018 1019// StartPreparer prepares the Start request. 1020func (client ClustersClient) StartPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 1021 pathParameters := map[string]interface{}{ 1022 "clusterName": autorest.Encode("path", clusterName), 1023 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1024 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1025 } 1026 1027 const APIVersion = "2019-11-09" 1028 queryParameters := map[string]interface{}{ 1029 "api-version": APIVersion, 1030 } 1031 1032 preparer := autorest.CreatePreparer( 1033 autorest.AsPost(), 1034 autorest.WithBaseURL(client.BaseURI), 1035 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/start", pathParameters), 1036 autorest.WithQueryParameters(queryParameters)) 1037 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1038} 1039 1040// StartSender sends the Start request. The method will close the 1041// http.Response Body if it receives an error. 1042func (client ClustersClient) StartSender(req *http.Request) (future ClustersStartFuture, err error) { 1043 var resp *http.Response 1044 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1045 if err != nil { 1046 return 1047 } 1048 var azf azure.Future 1049 azf, err = azure.NewFutureFromResponse(resp) 1050 future.FutureAPI = &azf 1051 future.Result = func(client ClustersClient) (ar autorest.Response, err error) { 1052 var done bool 1053 done, err = future.DoneWithContext(context.Background(), client) 1054 if err != nil { 1055 err = autorest.NewErrorWithError(err, "kusto.ClustersStartFuture", "Result", future.Response(), "Polling failure") 1056 return 1057 } 1058 if !done { 1059 err = azure.NewAsyncOpIncompleteError("kusto.ClustersStartFuture") 1060 return 1061 } 1062 ar.Response = future.Response() 1063 return 1064 } 1065 return 1066} 1067 1068// StartResponder handles the response to the Start request. The method always 1069// closes the http.Response Body. 1070func (client ClustersClient) StartResponder(resp *http.Response) (result autorest.Response, err error) { 1071 err = autorest.Respond( 1072 resp, 1073 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1074 autorest.ByClosing()) 1075 result.Response = resp 1076 return 1077} 1078 1079// Stop stops a Kusto cluster. 1080// Parameters: 1081// resourceGroupName - the name of the resource group containing the Kusto cluster. 1082// clusterName - the name of the Kusto cluster. 1083func (client ClustersClient) Stop(ctx context.Context, resourceGroupName string, clusterName string) (result ClustersStopFuture, err error) { 1084 if tracing.IsEnabled() { 1085 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.Stop") 1086 defer func() { 1087 sc := -1 1088 if result.Response() != nil { 1089 sc = result.Response().StatusCode 1090 } 1091 tracing.EndSpan(ctx, sc, err) 1092 }() 1093 } 1094 req, err := client.StopPreparer(ctx, resourceGroupName, clusterName) 1095 if err != nil { 1096 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Stop", nil, "Failure preparing request") 1097 return 1098 } 1099 1100 result, err = client.StopSender(req) 1101 if err != nil { 1102 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Stop", nil, "Failure sending request") 1103 return 1104 } 1105 1106 return 1107} 1108 1109// StopPreparer prepares the Stop request. 1110func (client ClustersClient) StopPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 1111 pathParameters := map[string]interface{}{ 1112 "clusterName": autorest.Encode("path", clusterName), 1113 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1114 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1115 } 1116 1117 const APIVersion = "2019-11-09" 1118 queryParameters := map[string]interface{}{ 1119 "api-version": APIVersion, 1120 } 1121 1122 preparer := autorest.CreatePreparer( 1123 autorest.AsPost(), 1124 autorest.WithBaseURL(client.BaseURI), 1125 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/stop", pathParameters), 1126 autorest.WithQueryParameters(queryParameters)) 1127 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1128} 1129 1130// StopSender sends the Stop request. The method will close the 1131// http.Response Body if it receives an error. 1132func (client ClustersClient) StopSender(req *http.Request) (future ClustersStopFuture, err error) { 1133 var resp *http.Response 1134 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1135 if err != nil { 1136 return 1137 } 1138 var azf azure.Future 1139 azf, err = azure.NewFutureFromResponse(resp) 1140 future.FutureAPI = &azf 1141 future.Result = func(client ClustersClient) (ar autorest.Response, err error) { 1142 var done bool 1143 done, err = future.DoneWithContext(context.Background(), client) 1144 if err != nil { 1145 err = autorest.NewErrorWithError(err, "kusto.ClustersStopFuture", "Result", future.Response(), "Polling failure") 1146 return 1147 } 1148 if !done { 1149 err = azure.NewAsyncOpIncompleteError("kusto.ClustersStopFuture") 1150 return 1151 } 1152 ar.Response = future.Response() 1153 return 1154 } 1155 return 1156} 1157 1158// StopResponder handles the response to the Stop request. The method always 1159// closes the http.Response Body. 1160func (client ClustersClient) StopResponder(resp *http.Response) (result autorest.Response, err error) { 1161 err = autorest.Respond( 1162 resp, 1163 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 1164 autorest.ByClosing()) 1165 result.Response = resp 1166 return 1167} 1168 1169// Update update a Kusto cluster. 1170// Parameters: 1171// resourceGroupName - the name of the resource group containing the Kusto cluster. 1172// clusterName - the name of the Kusto cluster. 1173// parameters - the Kusto cluster parameters supplied to the Update operation. 1174func (client ClustersClient) Update(ctx context.Context, resourceGroupName string, clusterName string, parameters ClusterUpdate) (result ClustersUpdateFuture, err error) { 1175 if tracing.IsEnabled() { 1176 ctx = tracing.StartSpan(ctx, fqdn+"/ClustersClient.Update") 1177 defer func() { 1178 sc := -1 1179 if result.Response() != nil { 1180 sc = result.Response().StatusCode 1181 } 1182 tracing.EndSpan(ctx, sc, err) 1183 }() 1184 } 1185 req, err := client.UpdatePreparer(ctx, resourceGroupName, clusterName, parameters) 1186 if err != nil { 1187 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Update", nil, "Failure preparing request") 1188 return 1189 } 1190 1191 result, err = client.UpdateSender(req) 1192 if err != nil { 1193 err = autorest.NewErrorWithError(err, "kusto.ClustersClient", "Update", nil, "Failure sending request") 1194 return 1195 } 1196 1197 return 1198} 1199 1200// UpdatePreparer prepares the Update request. 1201func (client ClustersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, parameters ClusterUpdate) (*http.Request, error) { 1202 pathParameters := map[string]interface{}{ 1203 "clusterName": autorest.Encode("path", clusterName), 1204 "resourceGroupName": autorest.Encode("path", resourceGroupName), 1205 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 1206 } 1207 1208 const APIVersion = "2019-11-09" 1209 queryParameters := map[string]interface{}{ 1210 "api-version": APIVersion, 1211 } 1212 1213 preparer := autorest.CreatePreparer( 1214 autorest.AsContentType("application/json; charset=utf-8"), 1215 autorest.AsPatch(), 1216 autorest.WithBaseURL(client.BaseURI), 1217 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}", pathParameters), 1218 autorest.WithJSON(parameters), 1219 autorest.WithQueryParameters(queryParameters)) 1220 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1221} 1222 1223// UpdateSender sends the Update request. The method will close the 1224// http.Response Body if it receives an error. 1225func (client ClustersClient) UpdateSender(req *http.Request) (future ClustersUpdateFuture, err error) { 1226 var resp *http.Response 1227 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 1228 if err != nil { 1229 return 1230 } 1231 var azf azure.Future 1232 azf, err = azure.NewFutureFromResponse(resp) 1233 future.FutureAPI = &azf 1234 future.Result = func(client ClustersClient) (c Cluster, err error) { 1235 var done bool 1236 done, err = future.DoneWithContext(context.Background(), client) 1237 if err != nil { 1238 err = autorest.NewErrorWithError(err, "kusto.ClustersUpdateFuture", "Result", future.Response(), "Polling failure") 1239 return 1240 } 1241 if !done { 1242 err = azure.NewAsyncOpIncompleteError("kusto.ClustersUpdateFuture") 1243 return 1244 } 1245 sender := autorest.DecorateSender(client, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1246 if c.Response.Response, err = future.GetResult(sender); err == nil && c.Response.Response.StatusCode != http.StatusNoContent { 1247 c, err = client.UpdateResponder(c.Response.Response) 1248 if err != nil { 1249 err = autorest.NewErrorWithError(err, "kusto.ClustersUpdateFuture", "Result", c.Response.Response, "Failure responding to request") 1250 } 1251 } 1252 return 1253 } 1254 return 1255} 1256 1257// UpdateResponder handles the response to the Update request. The method always 1258// closes the http.Response Body. 1259func (client ClustersClient) UpdateResponder(resp *http.Response) (result Cluster, err error) { 1260 err = autorest.Respond( 1261 resp, 1262 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted), 1263 autorest.ByUnmarshallingJSON(&result), 1264 autorest.ByClosing()) 1265 result.Response = autorest.Response{Response: resp} 1266 return 1267} 1268