databases.go

Documentation: github.com/Azure/azure-sdk-for-go/services/kusto/mgmt/2019-11-09/kusto

     1  package 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  
     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/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.
    21  type DatabasesClient struct {
    22  	BaseClient
    23  }
    24  
    25  // NewDatabasesClient creates an instance of the DatabasesClient client.
    26  func 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).
    32  func 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.
    42  func (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.
    76  func (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-11-09"
    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.
   101  func (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.
   107  func (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.
   122  func (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.
   162  func (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-11-09"
   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.
   186  func (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.
   192  func (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.
   208  func (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", result.Response(), "Failure sending request")
   228  		return
   229  	}
   230  
   231  	return
   232  }
   233  
   234  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
   235  func (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-11-09"
   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.
   260  func (client DatabasesClient) CreateOrUpdateSender(req *http.Request) (future DatabasesCreateOrUpdateFuture, err error) {
   261  	var resp *http.Response
   262  	future.FutureAPI = &azure.Future{}
   263  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   264  	if err != nil {
   265  		return
   266  	}
   267  	var azf azure.Future
   268  	azf, err = azure.NewFutureFromResponse(resp)
   269  	future.FutureAPI = &azf
   270  	future.Result = future.result
   271  	return
   272  }
   273  
   274  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   275  // closes the http.Response Body.
   276  func (client DatabasesClient) CreateOrUpdateResponder(resp *http.Response) (result DatabaseModel, err error) {
   277  	err = autorest.Respond(
   278  		resp,
   279  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted),
   280  		autorest.ByUnmarshallingJSON(&result.Value),
   281  		autorest.ByClosing())
   282  	result.Response = autorest.Response{Response: resp}
   283  	return
   284  }
   285  
   286  // Delete deletes the database with the given name.
   287  // Parameters:
   288  // resourceGroupName - the name of the resource group containing the Kusto cluster.
   289  // clusterName - the name of the Kusto cluster.
   290  // databaseName - the name of the database in the Kusto cluster.
   291  func (client DatabasesClient) Delete(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result DatabasesDeleteFuture, err error) {
   292  	if tracing.IsEnabled() {
   293  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Delete")
   294  		defer func() {
   295  			sc := -1
   296  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   297  				sc = result.FutureAPI.Response().StatusCode
   298  			}
   299  			tracing.EndSpan(ctx, sc, err)
   300  		}()
   301  	}
   302  	req, err := client.DeletePreparer(ctx, resourceGroupName, clusterName, databaseName)
   303  	if err != nil {
   304  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Delete", nil, "Failure preparing request")
   305  		return
   306  	}
   307  
   308  	result, err = client.DeleteSender(req)
   309  	if err != nil {
   310  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Delete", result.Response(), "Failure sending request")
   311  		return
   312  	}
   313  
   314  	return
   315  }
   316  
   317  // DeletePreparer prepares the Delete request.
   318  func (client DatabasesClient) DeletePreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) {
   319  	pathParameters := map[string]interface{}{
   320  		"clusterName":       autorest.Encode("path", clusterName),
   321  		"databaseName":      autorest.Encode("path", databaseName),
   322  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   323  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   324  	}
   325  
   326  	const APIVersion = "2019-11-09"
   327  	queryParameters := map[string]interface{}{
   328  		"api-version": APIVersion,
   329  	}
   330  
   331  	preparer := autorest.CreatePreparer(
   332  		autorest.AsDelete(),
   333  		autorest.WithBaseURL(client.BaseURI),
   334  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}", pathParameters),
   335  		autorest.WithQueryParameters(queryParameters))
   336  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   337  }
   338  
   339  // DeleteSender sends the Delete request. The method will close the
   340  // http.Response Body if it receives an error.
   341  func (client DatabasesClient) DeleteSender(req *http.Request) (future DatabasesDeleteFuture, err error) {
   342  	var resp *http.Response
   343  	future.FutureAPI = &azure.Future{}
   344  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   345  	if err != nil {
   346  		return
   347  	}
   348  	var azf azure.Future
   349  	azf, err = azure.NewFutureFromResponse(resp)
   350  	future.FutureAPI = &azf
   351  	future.Result = future.result
   352  	return
   353  }
   354  
   355  // DeleteResponder handles the response to the Delete request. The method always
   356  // closes the http.Response Body.
   357  func (client DatabasesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   358  	err = autorest.Respond(
   359  		resp,
   360  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   361  		autorest.ByClosing())
   362  	result.Response = resp
   363  	return
   364  }
   365  
   366  // Get returns a database.
   367  // Parameters:
   368  // resourceGroupName - the name of the resource group containing the Kusto cluster.
   369  // clusterName - the name of the Kusto cluster.
   370  // databaseName - the name of the database in the Kusto cluster.
   371  func (client DatabasesClient) Get(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result DatabaseModel, err error) {
   372  	if tracing.IsEnabled() {
   373  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Get")
   374  		defer func() {
   375  			sc := -1
   376  			if result.Response.Response != nil {
   377  				sc = result.Response.Response.StatusCode
   378  			}
   379  			tracing.EndSpan(ctx, sc, err)
   380  		}()
   381  	}
   382  	req, err := client.GetPreparer(ctx, resourceGroupName, clusterName, databaseName)
   383  	if err != nil {
   384  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Get", nil, "Failure preparing request")
   385  		return
   386  	}
   387  
   388  	resp, err := client.GetSender(req)
   389  	if err != nil {
   390  		result.Response = autorest.Response{Response: resp}
   391  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Get", resp, "Failure sending request")
   392  		return
   393  	}
   394  
   395  	result, err = client.GetResponder(resp)
   396  	if err != nil {
   397  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Get", resp, "Failure responding to request")
   398  		return
   399  	}
   400  
   401  	return
   402  }
   403  
   404  // GetPreparer prepares the Get request.
   405  func (client DatabasesClient) GetPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) {
   406  	pathParameters := map[string]interface{}{
   407  		"clusterName":       autorest.Encode("path", clusterName),
   408  		"databaseName":      autorest.Encode("path", databaseName),
   409  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   410  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   411  	}
   412  
   413  	const APIVersion = "2019-11-09"
   414  	queryParameters := map[string]interface{}{
   415  		"api-version": APIVersion,
   416  	}
   417  
   418  	preparer := autorest.CreatePreparer(
   419  		autorest.AsGet(),
   420  		autorest.WithBaseURL(client.BaseURI),
   421  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}", pathParameters),
   422  		autorest.WithQueryParameters(queryParameters))
   423  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   424  }
   425  
   426  // GetSender sends the Get request. The method will close the
   427  // http.Response Body if it receives an error.
   428  func (client DatabasesClient) GetSender(req *http.Request) (*http.Response, error) {
   429  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   430  }
   431  
   432  // GetResponder handles the response to the Get request. The method always
   433  // closes the http.Response Body.
   434  func (client DatabasesClient) GetResponder(resp *http.Response) (result DatabaseModel, 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  
   444  // ListByCluster returns the list of databases of the given Kusto cluster.
   445  // Parameters:
   446  // resourceGroupName - the name of the resource group containing the Kusto cluster.
   447  // clusterName - the name of the Kusto cluster.
   448  func (client DatabasesClient) ListByCluster(ctx context.Context, resourceGroupName string, clusterName string) (result DatabaseListResult, err error) {
   449  	if tracing.IsEnabled() {
   450  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListByCluster")
   451  		defer func() {
   452  			sc := -1
   453  			if result.Response.Response != nil {
   454  				sc = result.Response.Response.StatusCode
   455  			}
   456  			tracing.EndSpan(ctx, sc, err)
   457  		}()
   458  	}
   459  	req, err := client.ListByClusterPreparer(ctx, resourceGroupName, clusterName)
   460  	if err != nil {
   461  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListByCluster", nil, "Failure preparing request")
   462  		return
   463  	}
   464  
   465  	resp, err := client.ListByClusterSender(req)
   466  	if err != nil {
   467  		result.Response = autorest.Response{Response: resp}
   468  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListByCluster", resp, "Failure sending request")
   469  		return
   470  	}
   471  
   472  	result, err = client.ListByClusterResponder(resp)
   473  	if err != nil {
   474  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListByCluster", resp, "Failure responding to request")
   475  		return
   476  	}
   477  
   478  	return
   479  }
   480  
   481  // ListByClusterPreparer prepares the ListByCluster request.
   482  func (client DatabasesClient) ListByClusterPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) {
   483  	pathParameters := map[string]interface{}{
   484  		"clusterName":       autorest.Encode("path", clusterName),
   485  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   486  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   487  	}
   488  
   489  	const APIVersion = "2019-11-09"
   490  	queryParameters := map[string]interface{}{
   491  		"api-version": APIVersion,
   492  	}
   493  
   494  	preparer := autorest.CreatePreparer(
   495  		autorest.AsGet(),
   496  		autorest.WithBaseURL(client.BaseURI),
   497  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases", pathParameters),
   498  		autorest.WithQueryParameters(queryParameters))
   499  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   500  }
   501  
   502  // ListByClusterSender sends the ListByCluster request. The method will close the
   503  // http.Response Body if it receives an error.
   504  func (client DatabasesClient) ListByClusterSender(req *http.Request) (*http.Response, error) {
   505  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   506  }
   507  
   508  // ListByClusterResponder handles the response to the ListByCluster request. The method always
   509  // closes the http.Response Body.
   510  func (client DatabasesClient) ListByClusterResponder(resp *http.Response) (result DatabaseListResult, err error) {
   511  	err = autorest.Respond(
   512  		resp,
   513  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   514  		autorest.ByUnmarshallingJSON(&result),
   515  		autorest.ByClosing())
   516  	result.Response = autorest.Response{Response: resp}
   517  	return
   518  }
   519  
   520  // ListPrincipals returns a list of database principals of the given Kusto cluster and database.
   521  // Parameters:
   522  // resourceGroupName - the name of the resource group containing the Kusto cluster.
   523  // clusterName - the name of the Kusto cluster.
   524  // databaseName - the name of the database in the Kusto cluster.
   525  func (client DatabasesClient) ListPrincipals(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (result DatabasePrincipalListResult, err error) {
   526  	if tracing.IsEnabled() {
   527  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListPrincipals")
   528  		defer func() {
   529  			sc := -1
   530  			if result.Response.Response != nil {
   531  				sc = result.Response.Response.StatusCode
   532  			}
   533  			tracing.EndSpan(ctx, sc, err)
   534  		}()
   535  	}
   536  	req, err := client.ListPrincipalsPreparer(ctx, resourceGroupName, clusterName, databaseName)
   537  	if err != nil {
   538  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListPrincipals", nil, "Failure preparing request")
   539  		return
   540  	}
   541  
   542  	resp, err := client.ListPrincipalsSender(req)
   543  	if err != nil {
   544  		result.Response = autorest.Response{Response: resp}
   545  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListPrincipals", resp, "Failure sending request")
   546  		return
   547  	}
   548  
   549  	result, err = client.ListPrincipalsResponder(resp)
   550  	if err != nil {
   551  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "ListPrincipals", resp, "Failure responding to request")
   552  		return
   553  	}
   554  
   555  	return
   556  }
   557  
   558  // ListPrincipalsPreparer prepares the ListPrincipals request.
   559  func (client DatabasesClient) ListPrincipalsPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string) (*http.Request, error) {
   560  	pathParameters := map[string]interface{}{
   561  		"clusterName":       autorest.Encode("path", clusterName),
   562  		"databaseName":      autorest.Encode("path", databaseName),
   563  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   564  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   565  	}
   566  
   567  	const APIVersion = "2019-11-09"
   568  	queryParameters := map[string]interface{}{
   569  		"api-version": APIVersion,
   570  	}
   571  
   572  	preparer := autorest.CreatePreparer(
   573  		autorest.AsPost(),
   574  		autorest.WithBaseURL(client.BaseURI),
   575  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}/listPrincipals", pathParameters),
   576  		autorest.WithQueryParameters(queryParameters))
   577  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   578  }
   579  
   580  // ListPrincipalsSender sends the ListPrincipals request. The method will close the
   581  // http.Response Body if it receives an error.
   582  func (client DatabasesClient) ListPrincipalsSender(req *http.Request) (*http.Response, error) {
   583  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   584  }
   585  
   586  // ListPrincipalsResponder handles the response to the ListPrincipals request. The method always
   587  // closes the http.Response Body.
   588  func (client DatabasesClient) ListPrincipalsResponder(resp *http.Response) (result DatabasePrincipalListResult, err error) {
   589  	err = autorest.Respond(
   590  		resp,
   591  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   592  		autorest.ByUnmarshallingJSON(&result),
   593  		autorest.ByClosing())
   594  	result.Response = autorest.Response{Response: resp}
   595  	return
   596  }
   597  
   598  // RemovePrincipals remove Database principals permissions.
   599  // Parameters:
   600  // resourceGroupName - the name of the resource group containing the Kusto cluster.
   601  // clusterName - the name of the Kusto cluster.
   602  // databaseName - the name of the database in the Kusto cluster.
   603  // databasePrincipalsToRemove - list of database principals to remove.
   604  func (client DatabasesClient) RemovePrincipals(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, databasePrincipalsToRemove DatabasePrincipalListRequest) (result DatabasePrincipalListResult, err error) {
   605  	if tracing.IsEnabled() {
   606  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.RemovePrincipals")
   607  		defer func() {
   608  			sc := -1
   609  			if result.Response.Response != nil {
   610  				sc = result.Response.Response.StatusCode
   611  			}
   612  			tracing.EndSpan(ctx, sc, err)
   613  		}()
   614  	}
   615  	req, err := client.RemovePrincipalsPreparer(ctx, resourceGroupName, clusterName, databaseName, databasePrincipalsToRemove)
   616  	if err != nil {
   617  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "RemovePrincipals", nil, "Failure preparing request")
   618  		return
   619  	}
   620  
   621  	resp, err := client.RemovePrincipalsSender(req)
   622  	if err != nil {
   623  		result.Response = autorest.Response{Response: resp}
   624  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "RemovePrincipals", resp, "Failure sending request")
   625  		return
   626  	}
   627  
   628  	result, err = client.RemovePrincipalsResponder(resp)
   629  	if err != nil {
   630  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "RemovePrincipals", resp, "Failure responding to request")
   631  		return
   632  	}
   633  
   634  	return
   635  }
   636  
   637  // RemovePrincipalsPreparer prepares the RemovePrincipals request.
   638  func (client DatabasesClient) RemovePrincipalsPreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, databasePrincipalsToRemove DatabasePrincipalListRequest) (*http.Request, error) {
   639  	pathParameters := map[string]interface{}{
   640  		"clusterName":       autorest.Encode("path", clusterName),
   641  		"databaseName":      autorest.Encode("path", databaseName),
   642  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   643  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   644  	}
   645  
   646  	const APIVersion = "2019-11-09"
   647  	queryParameters := map[string]interface{}{
   648  		"api-version": APIVersion,
   649  	}
   650  
   651  	preparer := autorest.CreatePreparer(
   652  		autorest.AsContentType("application/json; charset=utf-8"),
   653  		autorest.AsPost(),
   654  		autorest.WithBaseURL(client.BaseURI),
   655  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}/removePrincipals", pathParameters),
   656  		autorest.WithJSON(databasePrincipalsToRemove),
   657  		autorest.WithQueryParameters(queryParameters))
   658  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   659  }
   660  
   661  // RemovePrincipalsSender sends the RemovePrincipals request. The method will close the
   662  // http.Response Body if it receives an error.
   663  func (client DatabasesClient) RemovePrincipalsSender(req *http.Request) (*http.Response, error) {
   664  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   665  }
   666  
   667  // RemovePrincipalsResponder handles the response to the RemovePrincipals request. The method always
   668  // closes the http.Response Body.
   669  func (client DatabasesClient) RemovePrincipalsResponder(resp *http.Response) (result DatabasePrincipalListResult, err error) {
   670  	err = autorest.Respond(
   671  		resp,
   672  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   673  		autorest.ByUnmarshallingJSON(&result),
   674  		autorest.ByClosing())
   675  	result.Response = autorest.Response{Response: resp}
   676  	return
   677  }
   678  
   679  // Update updates a database.
   680  // Parameters:
   681  // resourceGroupName - the name of the resource group containing the Kusto cluster.
   682  // clusterName - the name of the Kusto cluster.
   683  // databaseName - the name of the database in the Kusto cluster.
   684  // parameters - the database parameters supplied to the Update operation.
   685  func (client DatabasesClient) Update(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters BasicDatabase) (result DatabasesUpdateFuture, err error) {
   686  	if tracing.IsEnabled() {
   687  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Update")
   688  		defer func() {
   689  			sc := -1
   690  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   691  				sc = result.FutureAPI.Response().StatusCode
   692  			}
   693  			tracing.EndSpan(ctx, sc, err)
   694  		}()
   695  	}
   696  	req, err := client.UpdatePreparer(ctx, resourceGroupName, clusterName, databaseName, parameters)
   697  	if err != nil {
   698  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Update", nil, "Failure preparing request")
   699  		return
   700  	}
   701  
   702  	result, err = client.UpdateSender(req)
   703  	if err != nil {
   704  		err = autorest.NewErrorWithError(err, "kusto.DatabasesClient", "Update", result.Response(), "Failure sending request")
   705  		return
   706  	}
   707  
   708  	return
   709  }
   710  
   711  // UpdatePreparer prepares the Update request.
   712  func (client DatabasesClient) UpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, databaseName string, parameters BasicDatabase) (*http.Request, error) {
   713  	pathParameters := map[string]interface{}{
   714  		"clusterName":       autorest.Encode("path", clusterName),
   715  		"databaseName":      autorest.Encode("path", databaseName),
   716  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   717  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   718  	}
   719  
   720  	const APIVersion = "2019-11-09"
   721  	queryParameters := map[string]interface{}{
   722  		"api-version": APIVersion,
   723  	}
   724  
   725  	preparer := autorest.CreatePreparer(
   726  		autorest.AsContentType("application/json; charset=utf-8"),
   727  		autorest.AsPatch(),
   728  		autorest.WithBaseURL(client.BaseURI),
   729  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Kusto/clusters/{clusterName}/databases/{databaseName}", pathParameters),
   730  		autorest.WithJSON(parameters),
   731  		autorest.WithQueryParameters(queryParameters))
   732  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   733  }
   734  
   735  // UpdateSender sends the Update request. The method will close the
   736  // http.Response Body if it receives an error.
   737  func (client DatabasesClient) UpdateSender(req *http.Request) (future DatabasesUpdateFuture, err error) {
   738  	var resp *http.Response
   739  	future.FutureAPI = &azure.Future{}
   740  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   741  	if err != nil {
   742  		return
   743  	}
   744  	var azf azure.Future
   745  	azf, err = azure.NewFutureFromResponse(resp)
   746  	future.FutureAPI = &azf
   747  	future.Result = future.result
   748  	return
   749  }
   750  
   751  // UpdateResponder handles the response to the Update request. The method always
   752  // closes the http.Response Body.
   753  func (client DatabasesClient) UpdateResponder(resp *http.Response) (result DatabaseModel, err error) {
   754  	err = autorest.Respond(
   755  		resp,
   756  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted),
   757  		autorest.ByUnmarshallingJSON(&result.Value),
   758  		autorest.ByClosing())
   759  	result.Response = autorest.Response{Response: resp}
   760  	return
   761  }
   762
View as plain text