databases.go

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/mysql/mgmt/2020-07-01-preview/mysqlflexibleservers

     1  package mysqlflexibleservers
     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 Microsoft Azure management API provides create, read, update, and delete functionality
    19  // for Azure MySQL resources including servers, databases, firewall rules, VNET rules, log files and configurations
    20  // with new business model.
    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  // CreateOrUpdate creates a new database or updates an existing database.
    37  // Parameters:
    38  // resourceGroupName - the name of the resource group. The name is case insensitive.
    39  // serverName - the name of the server.
    40  // databaseName - the name of the database.
    41  // parameters - the required parameters for creating or updating a database.
    42  func (client DatabasesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, serverName string, databaseName string, parameters Database) (result DatabasesCreateOrUpdateFuture, err error) {
    43  	if tracing.IsEnabled() {
    44  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.CreateOrUpdate")
    45  		defer func() {
    46  			sc := -1
    47  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    48  				sc = result.FutureAPI.Response().StatusCode
    49  			}
    50  			tracing.EndSpan(ctx, sc, err)
    51  		}()
    52  	}
    53  	if err := validation.Validate([]validation.Validation{
    54  		{TargetValue: client.SubscriptionID,
    55  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
    56  		{TargetValue: resourceGroupName,
    57  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
    58  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
    59  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil {
    60  		return result, validation.NewError("mysqlflexibleservers.DatabasesClient", "CreateOrUpdate", err.Error())
    61  	}
    62  
    63  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, serverName, databaseName, parameters)
    64  	if err != nil {
    65  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "CreateOrUpdate", nil, "Failure preparing request")
    66  		return
    67  	}
    68  
    69  	result, err = client.CreateOrUpdateSender(req)
    70  	if err != nil {
    71  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "CreateOrUpdate", result.Response(), "Failure sending request")
    72  		return
    73  	}
    74  
    75  	return
    76  }
    77  
    78  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
    79  func (client DatabasesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string, parameters Database) (*http.Request, error) {
    80  	pathParameters := map[string]interface{}{
    81  		"databaseName":      autorest.Encode("path", databaseName),
    82  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    83  		"serverName":        autorest.Encode("path", serverName),
    84  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    85  	}
    86  
    87  	const APIVersion = "2020-07-01-preview"
    88  	queryParameters := map[string]interface{}{
    89  		"api-version": APIVersion,
    90  	}
    91  
    92  	preparer := autorest.CreatePreparer(
    93  		autorest.AsContentType("application/json; charset=utf-8"),
    94  		autorest.AsPut(),
    95  		autorest.WithBaseURL(client.BaseURI),
    96  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBForMySql/flexibleServers/{serverName}/databases/{databaseName}", pathParameters),
    97  		autorest.WithJSON(parameters),
    98  		autorest.WithQueryParameters(queryParameters))
    99  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   100  }
   101  
   102  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   103  // http.Response Body if it receives an error.
   104  func (client DatabasesClient) CreateOrUpdateSender(req *http.Request) (future DatabasesCreateOrUpdateFuture, err error) {
   105  	var resp *http.Response
   106  	future.FutureAPI = &azure.Future{}
   107  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   108  	if err != nil {
   109  		return
   110  	}
   111  	var azf azure.Future
   112  	azf, err = azure.NewFutureFromResponse(resp)
   113  	future.FutureAPI = &azf
   114  	future.Result = future.result
   115  	return
   116  }
   117  
   118  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   119  // closes the http.Response Body.
   120  func (client DatabasesClient) CreateOrUpdateResponder(resp *http.Response) (result Database, err error) {
   121  	err = autorest.Respond(
   122  		resp,
   123  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted),
   124  		autorest.ByUnmarshallingJSON(&result),
   125  		autorest.ByClosing())
   126  	result.Response = autorest.Response{Response: resp}
   127  	return
   128  }
   129  
   130  // Delete deletes a database.
   131  // Parameters:
   132  // resourceGroupName - the name of the resource group. The name is case insensitive.
   133  // serverName - the name of the server.
   134  // databaseName - the name of the database.
   135  func (client DatabasesClient) Delete(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (result DatabasesDeleteFuture, err error) {
   136  	if tracing.IsEnabled() {
   137  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Delete")
   138  		defer func() {
   139  			sc := -1
   140  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   141  				sc = result.FutureAPI.Response().StatusCode
   142  			}
   143  			tracing.EndSpan(ctx, sc, err)
   144  		}()
   145  	}
   146  	if err := validation.Validate([]validation.Validation{
   147  		{TargetValue: client.SubscriptionID,
   148  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   149  		{TargetValue: resourceGroupName,
   150  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   151  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   152  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil {
   153  		return result, validation.NewError("mysqlflexibleservers.DatabasesClient", "Delete", err.Error())
   154  	}
   155  
   156  	req, err := client.DeletePreparer(ctx, resourceGroupName, serverName, databaseName)
   157  	if err != nil {
   158  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "Delete", nil, "Failure preparing request")
   159  		return
   160  	}
   161  
   162  	result, err = client.DeleteSender(req)
   163  	if err != nil {
   164  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "Delete", result.Response(), "Failure sending request")
   165  		return
   166  	}
   167  
   168  	return
   169  }
   170  
   171  // DeletePreparer prepares the Delete request.
   172  func (client DatabasesClient) DeletePreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (*http.Request, error) {
   173  	pathParameters := map[string]interface{}{
   174  		"databaseName":      autorest.Encode("path", databaseName),
   175  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   176  		"serverName":        autorest.Encode("path", serverName),
   177  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   178  	}
   179  
   180  	const APIVersion = "2020-07-01-preview"
   181  	queryParameters := map[string]interface{}{
   182  		"api-version": APIVersion,
   183  	}
   184  
   185  	preparer := autorest.CreatePreparer(
   186  		autorest.AsDelete(),
   187  		autorest.WithBaseURL(client.BaseURI),
   188  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBForMySql/flexibleServers/{serverName}/databases/{databaseName}", pathParameters),
   189  		autorest.WithQueryParameters(queryParameters))
   190  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   191  }
   192  
   193  // DeleteSender sends the Delete request. The method will close the
   194  // http.Response Body if it receives an error.
   195  func (client DatabasesClient) DeleteSender(req *http.Request) (future DatabasesDeleteFuture, err error) {
   196  	var resp *http.Response
   197  	future.FutureAPI = &azure.Future{}
   198  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   199  	if err != nil {
   200  		return
   201  	}
   202  	var azf azure.Future
   203  	azf, err = azure.NewFutureFromResponse(resp)
   204  	future.FutureAPI = &azf
   205  	future.Result = future.result
   206  	return
   207  }
   208  
   209  // DeleteResponder handles the response to the Delete request. The method always
   210  // closes the http.Response Body.
   211  func (client DatabasesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   212  	err = autorest.Respond(
   213  		resp,
   214  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   215  		autorest.ByClosing())
   216  	result.Response = resp
   217  	return
   218  }
   219  
   220  // Get gets information about a database.
   221  // Parameters:
   222  // resourceGroupName - the name of the resource group. The name is case insensitive.
   223  // serverName - the name of the server.
   224  // databaseName - the name of the database.
   225  func (client DatabasesClient) Get(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (result Database, err error) {
   226  	if tracing.IsEnabled() {
   227  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.Get")
   228  		defer func() {
   229  			sc := -1
   230  			if result.Response.Response != nil {
   231  				sc = result.Response.Response.StatusCode
   232  			}
   233  			tracing.EndSpan(ctx, sc, err)
   234  		}()
   235  	}
   236  	if err := validation.Validate([]validation.Validation{
   237  		{TargetValue: client.SubscriptionID,
   238  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   239  		{TargetValue: resourceGroupName,
   240  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   241  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   242  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil {
   243  		return result, validation.NewError("mysqlflexibleservers.DatabasesClient", "Get", err.Error())
   244  	}
   245  
   246  	req, err := client.GetPreparer(ctx, resourceGroupName, serverName, databaseName)
   247  	if err != nil {
   248  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "Get", nil, "Failure preparing request")
   249  		return
   250  	}
   251  
   252  	resp, err := client.GetSender(req)
   253  	if err != nil {
   254  		result.Response = autorest.Response{Response: resp}
   255  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "Get", resp, "Failure sending request")
   256  		return
   257  	}
   258  
   259  	result, err = client.GetResponder(resp)
   260  	if err != nil {
   261  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "Get", resp, "Failure responding to request")
   262  		return
   263  	}
   264  
   265  	return
   266  }
   267  
   268  // GetPreparer prepares the Get request.
   269  func (client DatabasesClient) GetPreparer(ctx context.Context, resourceGroupName string, serverName string, databaseName string) (*http.Request, error) {
   270  	pathParameters := map[string]interface{}{
   271  		"databaseName":      autorest.Encode("path", databaseName),
   272  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   273  		"serverName":        autorest.Encode("path", serverName),
   274  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   275  	}
   276  
   277  	const APIVersion = "2020-07-01-preview"
   278  	queryParameters := map[string]interface{}{
   279  		"api-version": APIVersion,
   280  	}
   281  
   282  	preparer := autorest.CreatePreparer(
   283  		autorest.AsGet(),
   284  		autorest.WithBaseURL(client.BaseURI),
   285  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBForMySql/flexibleServers/{serverName}/databases/{databaseName}", pathParameters),
   286  		autorest.WithQueryParameters(queryParameters))
   287  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   288  }
   289  
   290  // GetSender sends the Get request. The method will close the
   291  // http.Response Body if it receives an error.
   292  func (client DatabasesClient) GetSender(req *http.Request) (*http.Response, error) {
   293  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   294  }
   295  
   296  // GetResponder handles the response to the Get request. The method always
   297  // closes the http.Response Body.
   298  func (client DatabasesClient) GetResponder(resp *http.Response) (result Database, err error) {
   299  	err = autorest.Respond(
   300  		resp,
   301  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   302  		autorest.ByUnmarshallingJSON(&result),
   303  		autorest.ByClosing())
   304  	result.Response = autorest.Response{Response: resp}
   305  	return
   306  }
   307  
   308  // ListByServer list all the databases in a given server.
   309  // Parameters:
   310  // resourceGroupName - the name of the resource group. The name is case insensitive.
   311  // serverName - the name of the server.
   312  func (client DatabasesClient) ListByServer(ctx context.Context, resourceGroupName string, serverName string) (result DatabaseListResultPage, err error) {
   313  	if tracing.IsEnabled() {
   314  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListByServer")
   315  		defer func() {
   316  			sc := -1
   317  			if result.dlr.Response.Response != nil {
   318  				sc = result.dlr.Response.Response.StatusCode
   319  			}
   320  			tracing.EndSpan(ctx, sc, err)
   321  		}()
   322  	}
   323  	if err := validation.Validate([]validation.Validation{
   324  		{TargetValue: client.SubscriptionID,
   325  			Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   326  		{TargetValue: resourceGroupName,
   327  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   328  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   329  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil {
   330  		return result, validation.NewError("mysqlflexibleservers.DatabasesClient", "ListByServer", err.Error())
   331  	}
   332  
   333  	result.fn = client.listByServerNextResults
   334  	req, err := client.ListByServerPreparer(ctx, resourceGroupName, serverName)
   335  	if err != nil {
   336  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "ListByServer", nil, "Failure preparing request")
   337  		return
   338  	}
   339  
   340  	resp, err := client.ListByServerSender(req)
   341  	if err != nil {
   342  		result.dlr.Response = autorest.Response{Response: resp}
   343  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "ListByServer", resp, "Failure sending request")
   344  		return
   345  	}
   346  
   347  	result.dlr, err = client.ListByServerResponder(resp)
   348  	if err != nil {
   349  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "ListByServer", resp, "Failure responding to request")
   350  		return
   351  	}
   352  	if result.dlr.hasNextLink() && result.dlr.IsEmpty() {
   353  		err = result.NextWithContext(ctx)
   354  		return
   355  	}
   356  
   357  	return
   358  }
   359  
   360  // ListByServerPreparer prepares the ListByServer request.
   361  func (client DatabasesClient) ListByServerPreparer(ctx context.Context, resourceGroupName string, serverName string) (*http.Request, error) {
   362  	pathParameters := map[string]interface{}{
   363  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   364  		"serverName":        autorest.Encode("path", serverName),
   365  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   366  	}
   367  
   368  	const APIVersion = "2020-07-01-preview"
   369  	queryParameters := map[string]interface{}{
   370  		"api-version": APIVersion,
   371  	}
   372  
   373  	preparer := autorest.CreatePreparer(
   374  		autorest.AsGet(),
   375  		autorest.WithBaseURL(client.BaseURI),
   376  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBForMySql/flexibleServers/{serverName}/databases", pathParameters),
   377  		autorest.WithQueryParameters(queryParameters))
   378  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   379  }
   380  
   381  // ListByServerSender sends the ListByServer request. The method will close the
   382  // http.Response Body if it receives an error.
   383  func (client DatabasesClient) ListByServerSender(req *http.Request) (*http.Response, error) {
   384  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   385  }
   386  
   387  // ListByServerResponder handles the response to the ListByServer request. The method always
   388  // closes the http.Response Body.
   389  func (client DatabasesClient) ListByServerResponder(resp *http.Response) (result DatabaseListResult, err error) {
   390  	err = autorest.Respond(
   391  		resp,
   392  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   393  		autorest.ByUnmarshallingJSON(&result),
   394  		autorest.ByClosing())
   395  	result.Response = autorest.Response{Response: resp}
   396  	return
   397  }
   398  
   399  // listByServerNextResults retrieves the next set of results, if any.
   400  func (client DatabasesClient) listByServerNextResults(ctx context.Context, lastResults DatabaseListResult) (result DatabaseListResult, err error) {
   401  	req, err := lastResults.databaseListResultPreparer(ctx)
   402  	if err != nil {
   403  		return result, autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "listByServerNextResults", nil, "Failure preparing next results request")
   404  	}
   405  	if req == nil {
   406  		return
   407  	}
   408  	resp, err := client.ListByServerSender(req)
   409  	if err != nil {
   410  		result.Response = autorest.Response{Response: resp}
   411  		return result, autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "listByServerNextResults", resp, "Failure sending next results request")
   412  	}
   413  	result, err = client.ListByServerResponder(resp)
   414  	if err != nil {
   415  		err = autorest.NewErrorWithError(err, "mysqlflexibleservers.DatabasesClient", "listByServerNextResults", resp, "Failure responding to next results request")
   416  	}
   417  	return
   418  }
   419  
   420  // ListByServerComplete enumerates all values, automatically crossing page boundaries as required.
   421  func (client DatabasesClient) ListByServerComplete(ctx context.Context, resourceGroupName string, serverName string) (result DatabaseListResultIterator, err error) {
   422  	if tracing.IsEnabled() {
   423  		ctx = tracing.StartSpan(ctx, fqdn+"/DatabasesClient.ListByServer")
   424  		defer func() {
   425  			sc := -1
   426  			if result.Response().Response.Response != nil {
   427  				sc = result.page.Response().Response.Response.StatusCode
   428  			}
   429  			tracing.EndSpan(ctx, sc, err)
   430  		}()
   431  	}
   432  	result.page, err = client.ListByServer(ctx, resourceGroupName, serverName)
   433  	return
   434  }
   435
View as plain text