1package kusto 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// 6// Code generated by Microsoft (R) AutoRest Code Generator. 7// Changes may cause incorrect behavior and will be lost if the code is regenerated. 8 9import ( 10 "context" 11 "github.com/Azure/go-autorest/autorest" 12 "github.com/Azure/go-autorest/autorest/azure" 13 "github.com/Azure/go-autorest/autorest/validation" 14 "github.com/Azure/go-autorest/tracing" 15 "net/http" 16) 17 18// DatabasesClient is the the Azure Kusto management API provides a RESTful set of web services that interact with 19// Azure Kusto services to manage your clusters and databases. The API enables you to create, update, and delete 20// clusters and databases. 21type DatabasesClient struct { 22 BaseClient 23} 24 25// NewDatabasesClient creates an instance of the DatabasesClient client. 26func NewDatabasesClient(subscriptionID string) DatabasesClient { 27 return NewDatabasesClientWithBaseURI(DefaultBaseURI, subscriptionID) 28} 29 30// NewDatabasesClientWithBaseURI creates an instance of the DatabasesClient client using a custom endpoint. Use this 31// when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 32func NewDatabasesClientWithBaseURI(baseURI string, subscriptionID string) DatabasesClient { 33 return DatabasesClient{NewWithBaseURI(baseURI, subscriptionID)} 34} 35 36// AddPrincipals add Database principals permissions. 37// Parameters: 38// resourceGroupName - the name of the resource group containing the Kusto cluster. 39// clusterName - the name of the Kusto cluster. 40// databaseName - the name of the database in the Kusto cluster. 41// databasePrincipalsToAdd - list of database principals to add. 42func (client DatabasesClient) AddPrincipals(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, databasePrincipalsToAdd DatabasePrincipalListRequest) (result DatabasePrincipalListResult, err error) { 43 if tracing.IsEnabled() { 44 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.AddPrincipals") 45 defer func() { 46 sc := -1 47 if result.Response.Response != nil { 48 sc = result.Response.Response.StatusCode 49 } 50 tracing.EndSpan(ctx, sc, err) 51 }() 52 } 53 req, err := client.AddPrincipalsPreparer(ctx, resourceGroupName, clusterName, databaseName, databasePrincipalsToAdd) 54 if err != nil { 55 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "AddPrincipals", nil, "Failure preparing request") 56 return 57 } 58 59 resp, err := client.AddPrincipalsSender(req) 60 if err != nil { 61 result.Response = autorest.Response{Response: resp} 62 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "AddPrincipals", resp, "Failure sending request") 63 return 64 } 65 66 result, err = client.AddPrincipalsResponder(resp) 67 if err != nil { 68 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "AddPrincipals", resp, "Failure responding to request") 69 return 70 } 71 72 return 73} 74 75// AddPrincipalsPreparer prepares the AddPrincipals request. 76func (client DatabasesClient) AddPrincipalsPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, databasePrincipalsToAdd DatabasePrincipalListRequest) (*http.Request, error) { 77 pathParameters := map[string]interface{}{ 78 "clusterName": autorest.Encode("path", clusterName), 79 "databaseName": autorest.Encode("path", databaseName), 80 "resourceGroupName": autorest.Encode("path", resourceGroupName), 81 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 82 } 83 84 const APIVersion = "2019-09-07" 85 queryParameters := map[string]interface{}{ 86 "api-version": APIVersion, 87 } 88 89 preparer := autorest.CreatePreparer( 90 autorest.AsContentType("application/json; charset=utf-8"), 91 autorest.AsPost(), 92 autorest.WithBaseURL(client.BaseURI), 93 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}/addPrincipals", pathParameters), 94 autorest.WithJSON(databasePrincipalsToAdd), 95 autorest.WithQueryParameters(queryParameters)) 96 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 97} 98 99// AddPrincipalsSender sends the AddPrincipals request. The method will close the 100// http.Response Body if it receives an error. 101func (client DatabasesClient) AddPrincipalsSender(req *http.Request) (*http.Response, error) { 102 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 103} 104 105// AddPrincipalsResponder handles the response to the AddPrincipals request. The method always 106// closes the http.Response Body. 107func (client DatabasesClient) AddPrincipalsResponder(resp *http.Response) (result DatabasePrincipalListResult, err error) { 108 err = autorest.Respond( 109 resp, 110 azure.WithErrorUnlessStatusCode(http.StatusOK), 111 autorest.ByUnmarshallingJSON(&result), 112 autorest.ByClosing()) 113 result.Response = autorest.Response{Response: resp} 114 return 115} 116 117// CheckNameAvailability checks that the database name is valid and is not already in use. 118// Parameters: 119// resourceGroupName - the name of the resource group containing the Kusto cluster. 120// clusterName - the name of the Kusto cluster. 121// resourceName - the name of the resource. 122func (client DatabasesClient) CheckNameAvailability(ctx context.Context, resourceGroupName string, clusterName string, resourceName CheckNameRequest) (result CheckNameResult, err error) { 123 if tracing.IsEnabled() { 124 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.CheckNameAvailability") 125 defer func() { 126 sc := -1 127 if result.Response.Response != nil { 128 sc = result.Response.Response.StatusCode 129 } 130 tracing.EndSpan(ctx, sc, err) 131 }() 132 } 133 if err := validation.Validate([]validation.Validation{ 134 {TargetValue: resourceName, 135 Constraints: []validation.Constraint{{Target: "resourceName.Name", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 136 return result, validation.NewError("kusto.DatabasesClient", "CheckNameAvailability", err.Error()) 137 } 138 139 req, err := client.CheckNameAvailabilityPreparer(ctx, resourceGroupName, clusterName, resourceName) 140 if err != nil { 141 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "CheckNameAvailability", nil, "Failure preparing request") 142 return 143 } 144 145 resp, err := client.CheckNameAvailabilitySender(req) 146 if err != nil { 147 result.Response = autorest.Response{Response: resp} 148 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "CheckNameAvailability", resp, "Failure sending request") 149 return 150 } 151 152 result, err = client.CheckNameAvailabilityResponder(resp) 153 if err != nil { 154 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "CheckNameAvailability", resp, "Failure responding to request") 155 return 156 } 157 158 return 159} 160 161// CheckNameAvailabilityPreparer prepares the CheckNameAvailability request. 162func (client DatabasesClient) CheckNameAvailabilityPreparer(ctx context.Context, resourceGroupName string, clusterName string, resourceName CheckNameRequest) (*http.Request, error) { 163 pathParameters := map[string]interface{}{ 164 "clusterName": autorest.Encode("path", clusterName), 165 "resourceGroupName": autorest.Encode("path", resourceGroupName), 166 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 167 } 168 169 const APIVersion = "2019-09-07" 170 queryParameters := map[string]interface{}{ 171 "api-version": APIVersion, 172 } 173 174 preparer := autorest.CreatePreparer( 175 autorest.AsContentType("application/json; charset=utf-8"), 176 autorest.AsPost(), 177 autorest.WithBaseURL(client.BaseURI), 178 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/checkNameAvailability", pathParameters), 179 autorest.WithJSON(resourceName), 180 autorest.WithQueryParameters(queryParameters)) 181 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 182} 183 184// CheckNameAvailabilitySender sends the CheckNameAvailability request. The method will close the 185// http.Response Body if it receives an error. 186func (client DatabasesClient) CheckNameAvailabilitySender(req *http.Request) (*http.Response, error) { 187 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 188} 189 190// CheckNameAvailabilityResponder handles the response to the CheckNameAvailability request. The method always 191// closes the http.Response Body. 192func (client DatabasesClient) CheckNameAvailabilityResponder(resp *http.Response) (result CheckNameResult, err error) { 193 err = autorest.Respond( 194 resp, 195 azure.WithErrorUnlessStatusCode(http.StatusOK), 196 autorest.ByUnmarshallingJSON(&result), 197 autorest.ByClosing()) 198 result.Response = autorest.Response{Response: resp} 199 return 200} 201 202// CreateOrUpdate creates or updates a database. 203// Parameters: 204// resourceGroupName - the name of the resource group containing the Kusto cluster. 205// clusterName - the name of the Kusto cluster. 206// databaseName - the name of the database in the Kusto cluster. 207// parameters - the database parameters supplied to the CreateOrUpdate operation. 208func (client DatabasesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters BasicDatabase) (result DatabasesCreateOrUpdateFuture, err error) { 209 if tracing.IsEnabled() { 210 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.CreateOrUpdate") 211 defer func() { 212 sc := -1 213 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 214 sc = result.FutureAPI.Response().StatusCode 215 } 216 tracing.EndSpan(ctx, sc, err) 217 }() 218 } 219 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, clusterName, databaseName, parameters) 220 if err != nil { 221 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "CreateOrUpdate", nil, "Failure preparing request") 222 return 223 } 224 225 result, err = client.CreateOrUpdateSender(req) 226 if err != nil { 227 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "CreateOrUpdate", nil, "Failure sending request") 228 return 229 } 230 231 return 232} 233 234// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 235func (client DatabasesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters BasicDatabase) (*http.Request, error) { 236 pathParameters := map[string]interface{}{ 237 "clusterName": autorest.Encode("path", clusterName), 238 "databaseName": autorest.Encode("path", databaseName), 239 "resourceGroupName": autorest.Encode("path", resourceGroupName), 240 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 241 } 242 243 const APIVersion = "2019-09-07" 244 queryParameters := map[string]interface{}{ 245 "api-version": APIVersion, 246 } 247 248 preparer := autorest.CreatePreparer( 249 autorest.AsContentType("application/json; charset=utf-8"), 250 autorest.AsPut(), 251 autorest.WithBaseURL(client.BaseURI), 252 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}", pathParameters), 253 autorest.WithJSON(parameters), 254 autorest.WithQueryParameters(queryParameters)) 255 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 256} 257 258// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 259// http.Response Body if it receives an error. 260func (client DatabasesClient) CreateOrUpdateSender(req *http.Request) (future DatabasesCreateOrUpdateFuture, err error) { 261 var resp *http.Response 262 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 263 if err != nil { 264 return 265 } 266 var azf azure.Future 267 azf, err = azure.NewFutureFromResponse(resp) 268 future.FutureAPI = &azf 269 future.Result = future.result 270 return 271} 272 273// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 274// closes the http.Response Body. 275func (client DatabasesClient) CreateOrUpdateResponder(resp *http.Response) (result DatabaseModel, err error) { 276 err = autorest.Respond( 277 resp, 278 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted), 279 autorest.ByUnmarshallingJSON(&result), 280 autorest.ByClosing()) 281 result.Response = autorest.Response{Response: resp} 282 return 283} 284 285// Delete deletes the database with the given name. 286// Parameters: 287// resourceGroupName - the name of the resource group containing the Kusto cluster. 288// clusterName - the name of the Kusto cluster. 289// databaseName - the name of the database in the Kusto cluster. 290func (client DatabasesClient) Delete(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result DatabasesDeleteFuture, err error) { 291 if tracing.IsEnabled() { 292 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Delete") 293 defer func() { 294 sc := -1 295 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 296 sc = result.FutureAPI.Response().StatusCode 297 } 298 tracing.EndSpan(ctx, sc, err) 299 }() 300 } 301 req, err := client.DeletePreparer(ctx, resourceGroupName, clusterName, databaseName) 302 if err != nil { 303 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Delete", nil, "Failure preparing request") 304 return 305 } 306 307 result, err = client.DeleteSender(req) 308 if err != nil { 309 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Delete", nil, "Failure sending request") 310 return 311 } 312 313 return 314} 315 316// DeletePreparer prepares the Delete request. 317func (client DatabasesClient) DeletePreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) { 318 pathParameters := map[string]interface{}{ 319 "clusterName": autorest.Encode("path", clusterName), 320 "databaseName": autorest.Encode("path", databaseName), 321 "resourceGroupName": autorest.Encode("path", resourceGroupName), 322 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 323 } 324 325 const APIVersion = "2019-09-07" 326 queryParameters := map[string]interface{}{ 327 "api-version": APIVersion, 328 } 329 330 preparer := autorest.CreatePreparer( 331 autorest.AsDelete(), 332 autorest.WithBaseURL(client.BaseURI), 333 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}", pathParameters), 334 autorest.WithQueryParameters(queryParameters)) 335 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 336} 337 338// DeleteSender sends the Delete request. The method will close the 339// http.Response Body if it receives an error. 340func (client DatabasesClient) DeleteSender(req *http.Request) (future DatabasesDeleteFuture, err error) { 341 var resp *http.Response 342 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 343 if err != nil { 344 return 345 } 346 var azf azure.Future 347 azf, err = azure.NewFutureFromResponse(resp) 348 future.FutureAPI = &azf 349 future.Result = future.result 350 return 351} 352 353// DeleteResponder handles the response to the Delete request. The method always 354// closes the http.Response Body. 355func (client DatabasesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 356 err = autorest.Respond( 357 resp, 358 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 359 autorest.ByClosing()) 360 result.Response = resp 361 return 362} 363 364// Get returns a database. 365// Parameters: 366// resourceGroupName - the name of the resource group containing the Kusto cluster. 367// clusterName - the name of the Kusto cluster. 368// databaseName - the name of the database in the Kusto cluster. 369func (client DatabasesClient) Get(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result DatabaseModel, err error) { 370 if tracing.IsEnabled() { 371 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Get") 372 defer func() { 373 sc := -1 374 if result.Response.Response != nil { 375 sc = result.Response.Response.StatusCode 376 } 377 tracing.EndSpan(ctx, sc, err) 378 }() 379 } 380 req, err := client.GetPreparer(ctx, resourceGroupName, clusterName, databaseName) 381 if err != nil { 382 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Get", nil, "Failure preparing request") 383 return 384 } 385 386 resp, err := client.GetSender(req) 387 if err != nil { 388 result.Response = autorest.Response{Response: resp} 389 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Get", resp, "Failure sending request") 390 return 391 } 392 393 result, err = client.GetResponder(resp) 394 if err != nil { 395 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Get", resp, "Failure responding to request") 396 return 397 } 398 399 return 400} 401 402// GetPreparer prepares the Get request. 403func (client DatabasesClient) GetPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) { 404 pathParameters := map[string]interface{}{ 405 "clusterName": autorest.Encode("path", clusterName), 406 "databaseName": autorest.Encode("path", databaseName), 407 "resourceGroupName": autorest.Encode("path", resourceGroupName), 408 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 409 } 410 411 const APIVersion = "2019-09-07" 412 queryParameters := map[string]interface{}{ 413 "api-version": APIVersion, 414 } 415 416 preparer := autorest.CreatePreparer( 417 autorest.AsGet(), 418 autorest.WithBaseURL(client.BaseURI), 419 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}", pathParameters), 420 autorest.WithQueryParameters(queryParameters)) 421 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 422} 423 424// GetSender sends the Get request. The method will close the 425// http.Response Body if it receives an error. 426func (client DatabasesClient) GetSender(req *http.Request) (*http.Response, error) { 427 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 428} 429 430// GetResponder handles the response to the Get request. The method always 431// closes the http.Response Body. 432func (client DatabasesClient) GetResponder(resp *http.Response) (result DatabaseModel, err error) { 433 err = autorest.Respond( 434 resp, 435 azure.WithErrorUnlessStatusCode(http.StatusOK), 436 autorest.ByUnmarshallingJSON(&result), 437 autorest.ByClosing()) 438 result.Response = autorest.Response{Response: resp} 439 return 440} 441 442// ListByCluster returns the list of databases of the given Kusto cluster. 443// Parameters: 444// resourceGroupName - the name of the resource group containing the Kusto cluster. 445// clusterName - the name of the Kusto cluster. 446func (client DatabasesClient) ListByCluster(ctx context.Context, resourceGroupName string, clusterName string) (result DatabaseListResult, err error) { 447 if tracing.IsEnabled() { 448 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListByCluster") 449 defer func() { 450 sc := -1 451 if result.Response.Response != nil { 452 sc = result.Response.Response.StatusCode 453 } 454 tracing.EndSpan(ctx, sc, err) 455 }() 456 } 457 req, err := client.ListByClusterPreparer(ctx, resourceGroupName, clusterName) 458 if err != nil { 459 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListByCluster", nil, "Failure preparing request") 460 return 461 } 462 463 resp, err := client.ListByClusterSender(req) 464 if err != nil { 465 result.Response = autorest.Response{Response: resp} 466 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListByCluster", resp, "Failure sending request") 467 return 468 } 469 470 result, err = client.ListByClusterResponder(resp) 471 if err != nil { 472 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListByCluster", resp, "Failure responding to request") 473 return 474 } 475 476 return 477} 478 479// ListByClusterPreparer prepares the ListByCluster request. 480func (client DatabasesClient) ListByClusterPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) { 481 pathParameters := map[string]interface{}{ 482 "clusterName": autorest.Encode("path", clusterName), 483 "resourceGroupName": autorest.Encode("path", resourceGroupName), 484 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 485 } 486 487 const APIVersion = "2019-09-07" 488 queryParameters := map[string]interface{}{ 489 "api-version": APIVersion, 490 } 491 492 preparer := autorest.CreatePreparer( 493 autorest.AsGet(), 494 autorest.WithBaseURL(client.BaseURI), 495 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases", pathParameters), 496 autorest.WithQueryParameters(queryParameters)) 497 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 498} 499 500// ListByClusterSender sends the ListByCluster request. The method will close the 501// http.Response Body if it receives an error. 502func (client DatabasesClient) ListByClusterSender(req *http.Request) (*http.Response, error) { 503 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 504} 505 506// ListByClusterResponder handles the response to the ListByCluster request. The method always 507// closes the http.Response Body. 508func (client DatabasesClient) ListByClusterResponder(resp *http.Response) (result DatabaseListResult, err error) { 509 err = autorest.Respond( 510 resp, 511 azure.WithErrorUnlessStatusCode(http.StatusOK), 512 autorest.ByUnmarshallingJSON(&result), 513 autorest.ByClosing()) 514 result.Response = autorest.Response{Response: resp} 515 return 516} 517 518// ListPrincipals returns a list of database principals of the given Kusto cluster and database. 519// Parameters: 520// resourceGroupName - the name of the resource group containing the Kusto cluster. 521// clusterName - the name of the Kusto cluster. 522// databaseName - the name of the database in the Kusto cluster. 523func (client DatabasesClient) ListPrincipals(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result DatabasePrincipalListResult, err error) { 524 if tracing.IsEnabled() { 525 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListPrincipals") 526 defer func() { 527 sc := -1 528 if result.Response.Response != nil { 529 sc = result.Response.Response.StatusCode 530 } 531 tracing.EndSpan(ctx, sc, err) 532 }() 533 } 534 req, err := client.ListPrincipalsPreparer(ctx, resourceGroupName, clusterName, databaseName) 535 if err != nil { 536 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListPrincipals", nil, "Failure preparing request") 537 return 538 } 539 540 resp, err := client.ListPrincipalsSender(req) 541 if err != nil { 542 result.Response = autorest.Response{Response: resp} 543 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListPrincipals", resp, "Failure sending request") 544 return 545 } 546 547 result, err = client.ListPrincipalsResponder(resp) 548 if err != nil { 549 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListPrincipals", resp, "Failure responding to request") 550 return 551 } 552 553 return 554} 555 556// ListPrincipalsPreparer prepares the ListPrincipals request. 557func (client DatabasesClient) ListPrincipalsPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) { 558 pathParameters := map[string]interface{}{ 559 "clusterName": autorest.Encode("path", clusterName), 560 "databaseName": autorest.Encode("path", databaseName), 561 "resourceGroupName": autorest.Encode("path", resourceGroupName), 562 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 563 } 564 565 const APIVersion = "2019-09-07" 566 queryParameters := map[string]interface{}{ 567 "api-version": APIVersion, 568 } 569 570 preparer := autorest.CreatePreparer( 571 autorest.AsPost(), 572 autorest.WithBaseURL(client.BaseURI), 573 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}/listPrincipals", pathParameters), 574 autorest.WithQueryParameters(queryParameters)) 575 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 576} 577 578// ListPrincipalsSender sends the ListPrincipals request. The method will close the 579// http.Response Body if it receives an error. 580func (client DatabasesClient) ListPrincipalsSender(req *http.Request) (*http.Response, error) { 581 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 582} 583 584// ListPrincipalsResponder handles the response to the ListPrincipals request. The method always 585// closes the http.Response Body. 586func (client DatabasesClient) ListPrincipalsResponder(resp *http.Response) (result DatabasePrincipalListResult, err error) { 587 err = autorest.Respond( 588 resp, 589 azure.WithErrorUnlessStatusCode(http.StatusOK), 590 autorest.ByUnmarshallingJSON(&result), 591 autorest.ByClosing()) 592 result.Response = autorest.Response{Response: resp} 593 return 594} 595 596// RemovePrincipals remove Database principals permissions. 597// Parameters: 598// resourceGroupName - the name of the resource group containing the Kusto cluster. 599// clusterName - the name of the Kusto cluster. 600// databaseName - the name of the database in the Kusto cluster. 601// databasePrincipalsToRemove - list of database principals to remove. 602func (client DatabasesClient) RemovePrincipals(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, databasePrincipalsToRemove DatabasePrincipalListRequest) (result DatabasePrincipalListResult, err error) { 603 if tracing.IsEnabled() { 604 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.RemovePrincipals") 605 defer func() { 606 sc := -1 607 if result.Response.Response != nil { 608 sc = result.Response.Response.StatusCode 609 } 610 tracing.EndSpan(ctx, sc, err) 611 }() 612 } 613 req, err := client.RemovePrincipalsPreparer(ctx, resourceGroupName, clusterName, databaseName, databasePrincipalsToRemove) 614 if err != nil { 615 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "RemovePrincipals", nil, "Failure preparing request") 616 return 617 } 618 619 resp, err := client.RemovePrincipalsSender(req) 620 if err != nil { 621 result.Response = autorest.Response{Response: resp} 622 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "RemovePrincipals", resp, "Failure sending request") 623 return 624 } 625 626 result, err = client.RemovePrincipalsResponder(resp) 627 if err != nil { 628 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "RemovePrincipals", resp, "Failure responding to request") 629 return 630 } 631 632 return 633} 634 635// RemovePrincipalsPreparer prepares the RemovePrincipals request. 636func (client DatabasesClient) RemovePrincipalsPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, databasePrincipalsToRemove DatabasePrincipalListRequest) (*http.Request, error) { 637 pathParameters := map[string]interface{}{ 638 "clusterName": autorest.Encode("path", clusterName), 639 "databaseName": autorest.Encode("path", databaseName), 640 "resourceGroupName": autorest.Encode("path", resourceGroupName), 641 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 642 } 643 644 const APIVersion = "2019-09-07" 645 queryParameters := map[string]interface{}{ 646 "api-version": APIVersion, 647 } 648 649 preparer := autorest.CreatePreparer( 650 autorest.AsContentType("application/json; charset=utf-8"), 651 autorest.AsPost(), 652 autorest.WithBaseURL(client.BaseURI), 653 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}/removePrincipals", pathParameters), 654 autorest.WithJSON(databasePrincipalsToRemove), 655 autorest.WithQueryParameters(queryParameters)) 656 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 657} 658 659// RemovePrincipalsSender sends the RemovePrincipals request. The method will close the 660// http.Response Body if it receives an error. 661func (client DatabasesClient) RemovePrincipalsSender(req *http.Request) (*http.Response, error) { 662 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 663} 664 665// RemovePrincipalsResponder handles the response to the RemovePrincipals request. The method always 666// closes the http.Response Body. 667func (client DatabasesClient) RemovePrincipalsResponder(resp *http.Response) (result DatabasePrincipalListResult, err error) { 668 err = autorest.Respond( 669 resp, 670 azure.WithErrorUnlessStatusCode(http.StatusOK), 671 autorest.ByUnmarshallingJSON(&result), 672 autorest.ByClosing()) 673 result.Response = autorest.Response{Response: resp} 674 return 675} 676 677// Update updates a database. 678// Parameters: 679// resourceGroupName - the name of the resource group containing the Kusto cluster. 680// clusterName - the name of the Kusto cluster. 681// databaseName - the name of the database in the Kusto cluster. 682// parameters - the database parameters supplied to the Update operation. 683func (client DatabasesClient) Update(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters BasicDatabase) (result DatabasesUpdateFuture, err error) { 684 if tracing.IsEnabled() { 685 ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Update") 686 defer func() { 687 sc := -1 688 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 689 sc = result.FutureAPI.Response().StatusCode 690 } 691 tracing.EndSpan(ctx, sc, err) 692 }() 693 } 694 req, err := client.UpdatePreparer(ctx, resourceGroupName, clusterName, databaseName, parameters) 695 if err != nil { 696 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Update", nil, "Failure preparing request") 697 return 698 } 699 700 result, err = client.UpdateSender(req) 701 if err != nil { 702 err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Update", nil, "Failure sending request") 703 return 704 } 705 706 return 707} 708 709// UpdatePreparer prepares the Update request. 710func (client DatabasesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters BasicDatabase) (*http.Request, error) { 711 pathParameters := map[string]interface{}{ 712 "clusterName": autorest.Encode("path", clusterName), 713 "databaseName": autorest.Encode("path", databaseName), 714 "resourceGroupName": autorest.Encode("path", resourceGroupName), 715 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 716 } 717 718 const APIVersion = "2019-09-07" 719 queryParameters := map[string]interface{}{ 720 "api-version": APIVersion, 721 } 722 723 preparer := autorest.CreatePreparer( 724 autorest.AsContentType("application/json; charset=utf-8"), 725 autorest.AsPatch(), 726 autorest.WithBaseURL(client.BaseURI), 727 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}", pathParameters), 728 autorest.WithJSON(parameters), 729 autorest.WithQueryParameters(queryParameters)) 730 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 731} 732 733// UpdateSender sends the Update request. The method will close the 734// http.Response Body if it receives an error. 735func (client DatabasesClient) UpdateSender(req *http.Request) (future DatabasesUpdateFuture, err error) { 736 var resp *http.Response 737 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 738 if err != nil { 739 return 740 } 741 var azf azure.Future 742 azf, err = azure.NewFutureFromResponse(resp) 743 future.FutureAPI = &azf 744 future.Result = future.result 745 return 746} 747 748// UpdateResponder handles the response to the Update request. The method always 749// closes the http.Response Body. 750func (client DatabasesClient) UpdateResponder(resp *http.Response) (result DatabaseModel, err error) { 751 err = autorest.Respond( 752 resp, 753 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted), 754 autorest.ByUnmarshallingJSON(&result), 755 autorest.ByClosing()) 756 result.Response = autorest.Response{Response: resp} 757 return 758} 759