Source file src/github.com/Azure/azure-sdk-for-go/services/containerservice/mgmt/2020-09-01/containerservice/managedclusters.go

Documentation: github.com/Azure/azure-sdk-for-go/services/containerservice/mgmt/2020-09-01/containerservice

     1  package containerservice
     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  // ManagedClustersClient is the the Container Service Client.
    19  type ManagedClustersClient struct {
    20  	BaseClient
    21  }
    22  
    23  // NewManagedClustersClient creates an instance of the ManagedClustersClient client.
    24  func NewManagedClustersClient(subscriptionID string) ManagedClustersClient {
    25  	return NewManagedClustersClientWithBaseURI(DefaultBaseURI, subscriptionID)
    26  }
    27  
    28  // NewManagedClustersClientWithBaseURI creates an instance of the ManagedClustersClient client using a custom endpoint.
    29  // Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
    30  func NewManagedClustersClientWithBaseURI(baseURI string, subscriptionID string) ManagedClustersClient {
    31  	return ManagedClustersClient{NewWithBaseURI(baseURI, subscriptionID)}
    32  }
    33  
    34  // CreateOrUpdate creates or updates a managed cluster with the specified configuration for agents and Kubernetes
    35  // version.
    36  // Parameters:
    37  // resourceGroupName - the name of the resource group.
    38  // resourceName - the name of the managed cluster resource.
    39  // parameters - parameters supplied to the Create or Update a Managed Cluster operation.
    40  func (client ManagedClustersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedCluster) (result ManagedClustersCreateOrUpdateFuture, err error) {
    41  	if tracing.IsEnabled() {
    42  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.CreateOrUpdate")
    43  		defer func() {
    44  			sc := -1
    45  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
    46  				sc = result.FutureAPI.Response().StatusCode
    47  			}
    48  			tracing.EndSpan(ctx, sc, err)
    49  		}()
    50  	}
    51  	if err := validation.Validate([]validation.Validation{
    52  		{TargetValue: resourceGroupName,
    53  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
    54  		{TargetValue: resourceName,
    55  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
    56  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
    57  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}},
    58  		{TargetValue: parameters,
    59  			Constraints: []validation.Constraint{{Target: "parameters.ManagedClusterProperties", Name: validation.Null, Rule: false,
    60  				Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.LinuxProfile", Name: validation.Null, Rule: false,
    61  					Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.LinuxProfile.AdminUsername", Name: validation.Null, Rule: true,
    62  						Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.LinuxProfile.AdminUsername", Name: validation.Pattern, Rule: `^[A-Za-z][-A-Za-z0-9_]*$`, Chain: nil}}},
    63  						{Target: "parameters.ManagedClusterProperties.LinuxProfile.SSH", Name: validation.Null, Rule: true,
    64  							Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.LinuxProfile.SSH.PublicKeys", Name: validation.Null, Rule: true, Chain: nil}}},
    65  					}},
    66  					{Target: "parameters.ManagedClusterProperties.WindowsProfile", Name: validation.Null, Rule: false,
    67  						Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.WindowsProfile.AdminUsername", Name: validation.Null, Rule: true, Chain: nil}}},
    68  					{Target: "parameters.ManagedClusterProperties.ServicePrincipalProfile", Name: validation.Null, Rule: false,
    69  						Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.ServicePrincipalProfile.ClientID", Name: validation.Null, Rule: true, Chain: nil}}},
    70  					{Target: "parameters.ManagedClusterProperties.NetworkProfile", Name: validation.Null, Rule: false,
    71  						Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.PodCidr", Name: validation.Null, Rule: false,
    72  							Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.PodCidr", Name: validation.Pattern, Rule: `^([0-9]{1,3}\.){3}[0-9]{1,3}(\/([0-9]|[1-2][0-9]|3[0-2]))?$`, Chain: nil}}},
    73  							{Target: "parameters.ManagedClusterProperties.NetworkProfile.ServiceCidr", Name: validation.Null, Rule: false,
    74  								Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.ServiceCidr", Name: validation.Pattern, Rule: `^([0-9]{1,3}\.){3}[0-9]{1,3}(\/([0-9]|[1-2][0-9]|3[0-2]))?$`, Chain: nil}}},
    75  							{Target: "parameters.ManagedClusterProperties.NetworkProfile.DNSServiceIP", Name: validation.Null, Rule: false,
    76  								Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.DNSServiceIP", Name: validation.Pattern, Rule: `^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$`, Chain: nil}}},
    77  							{Target: "parameters.ManagedClusterProperties.NetworkProfile.DockerBridgeCidr", Name: validation.Null, Rule: false,
    78  								Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.DockerBridgeCidr", Name: validation.Pattern, Rule: `^([0-9]{1,3}\.){3}[0-9]{1,3}(\/([0-9]|[1-2][0-9]|3[0-2]))?$`, Chain: nil}}},
    79  							{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile", Name: validation.Null, Rule: false,
    80  								Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.ManagedOutboundIPs", Name: validation.Null, Rule: false,
    81  									Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.ManagedOutboundIPs.Count", Name: validation.Null, Rule: false,
    82  										Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.ManagedOutboundIPs.Count", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
    83  											{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.ManagedOutboundIPs.Count", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
    84  										}},
    85  									}},
    86  									{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.AllocatedOutboundPorts", Name: validation.Null, Rule: false,
    87  										Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.AllocatedOutboundPorts", Name: validation.InclusiveMaximum, Rule: int64(64000), Chain: nil},
    88  											{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.AllocatedOutboundPorts", Name: validation.InclusiveMinimum, Rule: int64(0), Chain: nil},
    89  										}},
    90  									{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.IdleTimeoutInMinutes", Name: validation.Null, Rule: false,
    91  										Chain: []validation.Constraint{{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.IdleTimeoutInMinutes", Name: validation.InclusiveMaximum, Rule: int64(120), Chain: nil},
    92  											{Target: "parameters.ManagedClusterProperties.NetworkProfile.LoadBalancerProfile.IdleTimeoutInMinutes", Name: validation.InclusiveMinimum, Rule: int64(4), Chain: nil},
    93  										}},
    94  								}},
    95  						}},
    96  				}}}}}); err != nil {
    97  		return result, validation.NewError("containerservice.ManagedClustersClient", "CreateOrUpdate", err.Error())
    98  	}
    99  
   100  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, resourceName, parameters)
   101  	if err != nil {
   102  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "CreateOrUpdate", nil, "Failure preparing request")
   103  		return
   104  	}
   105  
   106  	result, err = client.CreateOrUpdateSender(req)
   107  	if err != nil {
   108  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "CreateOrUpdate", result.Response(), "Failure sending request")
   109  		return
   110  	}
   111  
   112  	return
   113  }
   114  
   115  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
   116  func (client ManagedClustersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedCluster) (*http.Request, error) {
   117  	pathParameters := map[string]interface{}{
   118  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   119  		"resourceName":      autorest.Encode("path", resourceName),
   120  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   121  	}
   122  
   123  	const APIVersion = "2020-09-01"
   124  	queryParameters := map[string]interface{}{
   125  		"api-version": APIVersion,
   126  	}
   127  
   128  	preparer := autorest.CreatePreparer(
   129  		autorest.AsContentType("application/json; charset=utf-8"),
   130  		autorest.AsPut(),
   131  		autorest.WithBaseURL(client.BaseURI),
   132  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}", pathParameters),
   133  		autorest.WithJSON(parameters),
   134  		autorest.WithQueryParameters(queryParameters))
   135  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   136  }
   137  
   138  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   139  // http.Response Body if it receives an error.
   140  func (client ManagedClustersClient) CreateOrUpdateSender(req *http.Request) (future ManagedClustersCreateOrUpdateFuture, err error) {
   141  	var resp *http.Response
   142  	future.FutureAPI = &azure.Future{}
   143  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   144  	if err != nil {
   145  		return
   146  	}
   147  	var azf azure.Future
   148  	azf, err = azure.NewFutureFromResponse(resp)
   149  	future.FutureAPI = &azf
   150  	future.Result = future.result
   151  	return
   152  }
   153  
   154  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   155  // closes the http.Response Body.
   156  func (client ManagedClustersClient) CreateOrUpdateResponder(resp *http.Response) (result ManagedCluster, err error) {
   157  	err = autorest.Respond(
   158  		resp,
   159  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   160  		autorest.ByUnmarshallingJSON(&result),
   161  		autorest.ByClosing())
   162  	result.Response = autorest.Response{Response: resp}
   163  	return
   164  }
   165  
   166  // Delete deletes the managed cluster with a specified resource group and name.
   167  // Parameters:
   168  // resourceGroupName - the name of the resource group.
   169  // resourceName - the name of the managed cluster resource.
   170  func (client ManagedClustersClient) Delete(ctx context.Context, resourceGroupName string, resourceName string) (result ManagedClustersDeleteFuture, err error) {
   171  	if tracing.IsEnabled() {
   172  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.Delete")
   173  		defer func() {
   174  			sc := -1
   175  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   176  				sc = result.FutureAPI.Response().StatusCode
   177  			}
   178  			tracing.EndSpan(ctx, sc, err)
   179  		}()
   180  	}
   181  	if err := validation.Validate([]validation.Validation{
   182  		{TargetValue: resourceGroupName,
   183  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   184  		{TargetValue: resourceName,
   185  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
   186  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
   187  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   188  		return result, validation.NewError("containerservice.ManagedClustersClient", "Delete", err.Error())
   189  	}
   190  
   191  	req, err := client.DeletePreparer(ctx, resourceGroupName, resourceName)
   192  	if err != nil {
   193  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Delete", nil, "Failure preparing request")
   194  		return
   195  	}
   196  
   197  	result, err = client.DeleteSender(req)
   198  	if err != nil {
   199  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Delete", result.Response(), "Failure sending request")
   200  		return
   201  	}
   202  
   203  	return
   204  }
   205  
   206  // DeletePreparer prepares the Delete request.
   207  func (client ManagedClustersClient) DeletePreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   208  	pathParameters := map[string]interface{}{
   209  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   210  		"resourceName":      autorest.Encode("path", resourceName),
   211  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   212  	}
   213  
   214  	const APIVersion = "2020-09-01"
   215  	queryParameters := map[string]interface{}{
   216  		"api-version": APIVersion,
   217  	}
   218  
   219  	preparer := autorest.CreatePreparer(
   220  		autorest.AsDelete(),
   221  		autorest.WithBaseURL(client.BaseURI),
   222  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}", pathParameters),
   223  		autorest.WithQueryParameters(queryParameters))
   224  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   225  }
   226  
   227  // DeleteSender sends the Delete request. The method will close the
   228  // http.Response Body if it receives an error.
   229  func (client ManagedClustersClient) DeleteSender(req *http.Request) (future ManagedClustersDeleteFuture, err error) {
   230  	var resp *http.Response
   231  	future.FutureAPI = &azure.Future{}
   232  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   233  	if err != nil {
   234  		return
   235  	}
   236  	var azf azure.Future
   237  	azf, err = azure.NewFutureFromResponse(resp)
   238  	future.FutureAPI = &azf
   239  	future.Result = future.result
   240  	return
   241  }
   242  
   243  // DeleteResponder handles the response to the Delete request. The method always
   244  // closes the http.Response Body.
   245  func (client ManagedClustersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   246  	err = autorest.Respond(
   247  		resp,
   248  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   249  		autorest.ByClosing())
   250  	result.Response = resp
   251  	return
   252  }
   253  
   254  // Get gets the details of the managed cluster with a specified resource group and name.
   255  // Parameters:
   256  // resourceGroupName - the name of the resource group.
   257  // resourceName - the name of the managed cluster resource.
   258  func (client ManagedClustersClient) Get(ctx context.Context, resourceGroupName string, resourceName string) (result ManagedCluster, err error) {
   259  	if tracing.IsEnabled() {
   260  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.Get")
   261  		defer func() {
   262  			sc := -1
   263  			if result.Response.Response != nil {
   264  				sc = result.Response.Response.StatusCode
   265  			}
   266  			tracing.EndSpan(ctx, sc, err)
   267  		}()
   268  	}
   269  	if err := validation.Validate([]validation.Validation{
   270  		{TargetValue: resourceGroupName,
   271  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   272  		{TargetValue: resourceName,
   273  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
   274  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
   275  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   276  		return result, validation.NewError("containerservice.ManagedClustersClient", "Get", err.Error())
   277  	}
   278  
   279  	req, err := client.GetPreparer(ctx, resourceGroupName, resourceName)
   280  	if err != nil {
   281  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Get", nil, "Failure preparing request")
   282  		return
   283  	}
   284  
   285  	resp, err := client.GetSender(req)
   286  	if err != nil {
   287  		result.Response = autorest.Response{Response: resp}
   288  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Get", resp, "Failure sending request")
   289  		return
   290  	}
   291  
   292  	result, err = client.GetResponder(resp)
   293  	if err != nil {
   294  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Get", resp, "Failure responding to request")
   295  		return
   296  	}
   297  
   298  	return
   299  }
   300  
   301  // GetPreparer prepares the Get request.
   302  func (client ManagedClustersClient) GetPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   303  	pathParameters := map[string]interface{}{
   304  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   305  		"resourceName":      autorest.Encode("path", resourceName),
   306  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   307  	}
   308  
   309  	const APIVersion = "2020-09-01"
   310  	queryParameters := map[string]interface{}{
   311  		"api-version": APIVersion,
   312  	}
   313  
   314  	preparer := autorest.CreatePreparer(
   315  		autorest.AsGet(),
   316  		autorest.WithBaseURL(client.BaseURI),
   317  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}", pathParameters),
   318  		autorest.WithQueryParameters(queryParameters))
   319  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   320  }
   321  
   322  // GetSender sends the Get request. The method will close the
   323  // http.Response Body if it receives an error.
   324  func (client ManagedClustersClient) GetSender(req *http.Request) (*http.Response, error) {
   325  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   326  }
   327  
   328  // GetResponder handles the response to the Get request. The method always
   329  // closes the http.Response Body.
   330  func (client ManagedClustersClient) GetResponder(resp *http.Response) (result ManagedCluster, err error) {
   331  	err = autorest.Respond(
   332  		resp,
   333  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   334  		autorest.ByUnmarshallingJSON(&result),
   335  		autorest.ByClosing())
   336  	result.Response = autorest.Response{Response: resp}
   337  	return
   338  }
   339  
   340  // GetAccessProfile gets the accessProfile for the specified role name of the managed cluster with a specified resource
   341  // group and name. **WARNING**: This API will be deprecated. Instead use
   342  // [ListClusterUserCredentials](https://docs.microsoft.com/en-us/rest/api/aks/managedclusters/listclusterusercredentials)
   343  // or
   344  // [ListClusterAdminCredentials](https://docs.microsoft.com/en-us/rest/api/aks/managedclusters/listclusteradmincredentials)
   345  // .
   346  // Parameters:
   347  // resourceGroupName - the name of the resource group.
   348  // resourceName - the name of the managed cluster resource.
   349  // roleName - the name of the role for managed cluster accessProfile resource.
   350  func (client ManagedClustersClient) GetAccessProfile(ctx context.Context, resourceGroupName string, resourceName string, roleName string) (result ManagedClusterAccessProfile, err error) {
   351  	if tracing.IsEnabled() {
   352  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.GetAccessProfile")
   353  		defer func() {
   354  			sc := -1
   355  			if result.Response.Response != nil {
   356  				sc = result.Response.Response.StatusCode
   357  			}
   358  			tracing.EndSpan(ctx, sc, err)
   359  		}()
   360  	}
   361  	if err := validation.Validate([]validation.Validation{
   362  		{TargetValue: resourceGroupName,
   363  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   364  		{TargetValue: resourceName,
   365  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
   366  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
   367  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   368  		return result, validation.NewError("containerservice.ManagedClustersClient", "GetAccessProfile", err.Error())
   369  	}
   370  
   371  	req, err := client.GetAccessProfilePreparer(ctx, resourceGroupName, resourceName, roleName)
   372  	if err != nil {
   373  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "GetAccessProfile", nil, "Failure preparing request")
   374  		return
   375  	}
   376  
   377  	resp, err := client.GetAccessProfileSender(req)
   378  	if err != nil {
   379  		result.Response = autorest.Response{Response: resp}
   380  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "GetAccessProfile", resp, "Failure sending request")
   381  		return
   382  	}
   383  
   384  	result, err = client.GetAccessProfileResponder(resp)
   385  	if err != nil {
   386  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "GetAccessProfile", resp, "Failure responding to request")
   387  		return
   388  	}
   389  
   390  	return
   391  }
   392  
   393  // GetAccessProfilePreparer prepares the GetAccessProfile request.
   394  func (client ManagedClustersClient) GetAccessProfilePreparer(ctx context.Context, resourceGroupName string, resourceName string, roleName string) (*http.Request, error) {
   395  	pathParameters := map[string]interface{}{
   396  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   397  		"resourceName":      autorest.Encode("path", resourceName),
   398  		"roleName":          autorest.Encode("path", roleName),
   399  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   400  	}
   401  
   402  	const APIVersion = "2020-09-01"
   403  	queryParameters := map[string]interface{}{
   404  		"api-version": APIVersion,
   405  	}
   406  
   407  	preparer := autorest.CreatePreparer(
   408  		autorest.AsPost(),
   409  		autorest.WithBaseURL(client.BaseURI),
   410  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/accessProfiles/{roleName}/listCredential", pathParameters),
   411  		autorest.WithQueryParameters(queryParameters))
   412  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   413  }
   414  
   415  // GetAccessProfileSender sends the GetAccessProfile request. The method will close the
   416  // http.Response Body if it receives an error.
   417  func (client ManagedClustersClient) GetAccessProfileSender(req *http.Request) (*http.Response, error) {
   418  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   419  }
   420  
   421  // GetAccessProfileResponder handles the response to the GetAccessProfile request. The method always
   422  // closes the http.Response Body.
   423  func (client ManagedClustersClient) GetAccessProfileResponder(resp *http.Response) (result ManagedClusterAccessProfile, err error) {
   424  	err = autorest.Respond(
   425  		resp,
   426  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   427  		autorest.ByUnmarshallingJSON(&result),
   428  		autorest.ByClosing())
   429  	result.Response = autorest.Response{Response: resp}
   430  	return
   431  }
   432  
   433  // GetUpgradeProfile gets the details of the upgrade profile for a managed cluster with a specified resource group and
   434  // name.
   435  // Parameters:
   436  // resourceGroupName - the name of the resource group.
   437  // resourceName - the name of the managed cluster resource.
   438  func (client ManagedClustersClient) GetUpgradeProfile(ctx context.Context, resourceGroupName string, resourceName string) (result ManagedClusterUpgradeProfile, err error) {
   439  	if tracing.IsEnabled() {
   440  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.GetUpgradeProfile")
   441  		defer func() {
   442  			sc := -1
   443  			if result.Response.Response != nil {
   444  				sc = result.Response.Response.StatusCode
   445  			}
   446  			tracing.EndSpan(ctx, sc, err)
   447  		}()
   448  	}
   449  	if err := validation.Validate([]validation.Validation{
   450  		{TargetValue: resourceGroupName,
   451  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   452  		{TargetValue: resourceName,
   453  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
   454  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
   455  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   456  		return result, validation.NewError("containerservice.ManagedClustersClient", "GetUpgradeProfile", err.Error())
   457  	}
   458  
   459  	req, err := client.GetUpgradeProfilePreparer(ctx, resourceGroupName, resourceName)
   460  	if err != nil {
   461  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "GetUpgradeProfile", nil, "Failure preparing request")
   462  		return
   463  	}
   464  
   465  	resp, err := client.GetUpgradeProfileSender(req)
   466  	if err != nil {
   467  		result.Response = autorest.Response{Response: resp}
   468  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "GetUpgradeProfile", resp, "Failure sending request")
   469  		return
   470  	}
   471  
   472  	result, err = client.GetUpgradeProfileResponder(resp)
   473  	if err != nil {
   474  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "GetUpgradeProfile", resp, "Failure responding to request")
   475  		return
   476  	}
   477  
   478  	return
   479  }
   480  
   481  // GetUpgradeProfilePreparer prepares the GetUpgradeProfile request.
   482  func (client ManagedClustersClient) GetUpgradeProfilePreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   483  	pathParameters := map[string]interface{}{
   484  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   485  		"resourceName":      autorest.Encode("path", resourceName),
   486  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   487  	}
   488  
   489  	const APIVersion = "2020-09-01"
   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.ContainerService/managedClusters/{resourceName}/upgradeProfiles/default", pathParameters),
   498  		autorest.WithQueryParameters(queryParameters))
   499  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   500  }
   501  
   502  // GetUpgradeProfileSender sends the GetUpgradeProfile request. The method will close the
   503  // http.Response Body if it receives an error.
   504  func (client ManagedClustersClient) GetUpgradeProfileSender(req *http.Request) (*http.Response, error) {
   505  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   506  }
   507  
   508  // GetUpgradeProfileResponder handles the response to the GetUpgradeProfile request. The method always
   509  // closes the http.Response Body.
   510  func (client ManagedClustersClient) GetUpgradeProfileResponder(resp *http.Response) (result ManagedClusterUpgradeProfile, 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  // List gets a list of managed clusters in the specified subscription. The operation returns properties of each managed
   521  // cluster.
   522  func (client ManagedClustersClient) List(ctx context.Context) (result ManagedClusterListResultPage, err error) {
   523  	if tracing.IsEnabled() {
   524  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.List")
   525  		defer func() {
   526  			sc := -1
   527  			if result.mclr.Response.Response != nil {
   528  				sc = result.mclr.Response.Response.StatusCode
   529  			}
   530  			tracing.EndSpan(ctx, sc, err)
   531  		}()
   532  	}
   533  	result.fn = client.listNextResults
   534  	req, err := client.ListPreparer(ctx)
   535  	if err != nil {
   536  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "List", nil, "Failure preparing request")
   537  		return
   538  	}
   539  
   540  	resp, err := client.ListSender(req)
   541  	if err != nil {
   542  		result.mclr.Response = autorest.Response{Response: resp}
   543  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "List", resp, "Failure sending request")
   544  		return
   545  	}
   546  
   547  	result.mclr, err = client.ListResponder(resp)
   548  	if err != nil {
   549  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "List", resp, "Failure responding to request")
   550  		return
   551  	}
   552  	if result.mclr.hasNextLink() && result.mclr.IsEmpty() {
   553  		err = result.NextWithContext(ctx)
   554  		return
   555  	}
   556  
   557  	return
   558  }
   559  
   560  // ListPreparer prepares the List request.
   561  func (client ManagedClustersClient) ListPreparer(ctx context.Context) (*http.Request, error) {
   562  	pathParameters := map[string]interface{}{
   563  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   564  	}
   565  
   566  	const APIVersion = "2020-09-01"
   567  	queryParameters := map[string]interface{}{
   568  		"api-version": APIVersion,
   569  	}
   570  
   571  	preparer := autorest.CreatePreparer(
   572  		autorest.AsGet(),
   573  		autorest.WithBaseURL(client.BaseURI),
   574  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.ContainerService/managedClusters", pathParameters),
   575  		autorest.WithQueryParameters(queryParameters))
   576  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   577  }
   578  
   579  // ListSender sends the List request. The method will close the
   580  // http.Response Body if it receives an error.
   581  func (client ManagedClustersClient) ListSender(req *http.Request) (*http.Response, error) {
   582  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   583  }
   584  
   585  // ListResponder handles the response to the List request. The method always
   586  // closes the http.Response Body.
   587  func (client ManagedClustersClient) ListResponder(resp *http.Response) (result ManagedClusterListResult, err error) {
   588  	err = autorest.Respond(
   589  		resp,
   590  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   591  		autorest.ByUnmarshallingJSON(&result),
   592  		autorest.ByClosing())
   593  	result.Response = autorest.Response{Response: resp}
   594  	return
   595  }
   596  
   597  // listNextResults retrieves the next set of results, if any.
   598  func (client ManagedClustersClient) listNextResults(ctx context.Context, lastResults ManagedClusterListResult) (result ManagedClusterListResult, err error) {
   599  	req, err := lastResults.managedClusterListResultPreparer(ctx)
   600  	if err != nil {
   601  		return result, autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "listNextResults", nil, "Failure preparing next results request")
   602  	}
   603  	if req == nil {
   604  		return
   605  	}
   606  	resp, err := client.ListSender(req)
   607  	if err != nil {
   608  		result.Response = autorest.Response{Response: resp}
   609  		return result, autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "listNextResults", resp, "Failure sending next results request")
   610  	}
   611  	result, err = client.ListResponder(resp)
   612  	if err != nil {
   613  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "listNextResults", resp, "Failure responding to next results request")
   614  	}
   615  	return
   616  }
   617  
   618  // ListComplete enumerates all values, automatically crossing page boundaries as required.
   619  func (client ManagedClustersClient) ListComplete(ctx context.Context) (result ManagedClusterListResultIterator, err error) {
   620  	if tracing.IsEnabled() {
   621  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.List")
   622  		defer func() {
   623  			sc := -1
   624  			if result.Response().Response.Response != nil {
   625  				sc = result.page.Response().Response.Response.StatusCode
   626  			}
   627  			tracing.EndSpan(ctx, sc, err)
   628  		}()
   629  	}
   630  	result.page, err = client.List(ctx)
   631  	return
   632  }
   633  
   634  // ListByResourceGroup lists managed clusters in the specified subscription and resource group. The operation returns
   635  // properties of each managed cluster.
   636  // Parameters:
   637  // resourceGroupName - the name of the resource group.
   638  func (client ManagedClustersClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result ManagedClusterListResultPage, err error) {
   639  	if tracing.IsEnabled() {
   640  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.ListByResourceGroup")
   641  		defer func() {
   642  			sc := -1
   643  			if result.mclr.Response.Response != nil {
   644  				sc = result.mclr.Response.Response.StatusCode
   645  			}
   646  			tracing.EndSpan(ctx, sc, err)
   647  		}()
   648  	}
   649  	if err := validation.Validate([]validation.Validation{
   650  		{TargetValue: resourceGroupName,
   651  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}}}); err != nil {
   652  		return result, validation.NewError("containerservice.ManagedClustersClient", "ListByResourceGroup", err.Error())
   653  	}
   654  
   655  	result.fn = client.listByResourceGroupNextResults
   656  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
   657  	if err != nil {
   658  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListByResourceGroup", nil, "Failure preparing request")
   659  		return
   660  	}
   661  
   662  	resp, err := client.ListByResourceGroupSender(req)
   663  	if err != nil {
   664  		result.mclr.Response = autorest.Response{Response: resp}
   665  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListByResourceGroup", resp, "Failure sending request")
   666  		return
   667  	}
   668  
   669  	result.mclr, err = client.ListByResourceGroupResponder(resp)
   670  	if err != nil {
   671  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListByResourceGroup", resp, "Failure responding to request")
   672  		return
   673  	}
   674  	if result.mclr.hasNextLink() && result.mclr.IsEmpty() {
   675  		err = result.NextWithContext(ctx)
   676  		return
   677  	}
   678  
   679  	return
   680  }
   681  
   682  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
   683  func (client ManagedClustersClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
   684  	pathParameters := map[string]interface{}{
   685  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   686  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   687  	}
   688  
   689  	const APIVersion = "2020-09-01"
   690  	queryParameters := map[string]interface{}{
   691  		"api-version": APIVersion,
   692  	}
   693  
   694  	preparer := autorest.CreatePreparer(
   695  		autorest.AsGet(),
   696  		autorest.WithBaseURL(client.BaseURI),
   697  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters", pathParameters),
   698  		autorest.WithQueryParameters(queryParameters))
   699  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   700  }
   701  
   702  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
   703  // http.Response Body if it receives an error.
   704  func (client ManagedClustersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
   705  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   706  }
   707  
   708  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
   709  // closes the http.Response Body.
   710  func (client ManagedClustersClient) ListByResourceGroupResponder(resp *http.Response) (result ManagedClusterListResult, err error) {
   711  	err = autorest.Respond(
   712  		resp,
   713  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   714  		autorest.ByUnmarshallingJSON(&result),
   715  		autorest.ByClosing())
   716  	result.Response = autorest.Response{Response: resp}
   717  	return
   718  }
   719  
   720  // listByResourceGroupNextResults retrieves the next set of results, if any.
   721  func (client ManagedClustersClient) listByResourceGroupNextResults(ctx context.Context, lastResults ManagedClusterListResult) (result ManagedClusterListResult, err error) {
   722  	req, err := lastResults.managedClusterListResultPreparer(ctx)
   723  	if err != nil {
   724  		return result, autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
   725  	}
   726  	if req == nil {
   727  		return
   728  	}
   729  	resp, err := client.ListByResourceGroupSender(req)
   730  	if err != nil {
   731  		result.Response = autorest.Response{Response: resp}
   732  		return result, autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
   733  	}
   734  	result, err = client.ListByResourceGroupResponder(resp)
   735  	if err != nil {
   736  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
   737  	}
   738  	return
   739  }
   740  
   741  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
   742  func (client ManagedClustersClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result ManagedClusterListResultIterator, err error) {
   743  	if tracing.IsEnabled() {
   744  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.ListByResourceGroup")
   745  		defer func() {
   746  			sc := -1
   747  			if result.Response().Response.Response != nil {
   748  				sc = result.page.Response().Response.Response.StatusCode
   749  			}
   750  			tracing.EndSpan(ctx, sc, err)
   751  		}()
   752  	}
   753  	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
   754  	return
   755  }
   756  
   757  // ListClusterAdminCredentials gets cluster admin credential of the managed cluster with a specified resource group and
   758  // name.
   759  // Parameters:
   760  // resourceGroupName - the name of the resource group.
   761  // resourceName - the name of the managed cluster resource.
   762  func (client ManagedClustersClient) ListClusterAdminCredentials(ctx context.Context, resourceGroupName string, resourceName string) (result CredentialResults, err error) {
   763  	if tracing.IsEnabled() {
   764  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.ListClusterAdminCredentials")
   765  		defer func() {
   766  			sc := -1
   767  			if result.Response.Response != nil {
   768  				sc = result.Response.Response.StatusCode
   769  			}
   770  			tracing.EndSpan(ctx, sc, err)
   771  		}()
   772  	}
   773  	if err := validation.Validate([]validation.Validation{
   774  		{TargetValue: resourceGroupName,
   775  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   776  		{TargetValue: resourceName,
   777  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
   778  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
   779  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   780  		return result, validation.NewError("containerservice.ManagedClustersClient", "ListClusterAdminCredentials", err.Error())
   781  	}
   782  
   783  	req, err := client.ListClusterAdminCredentialsPreparer(ctx, resourceGroupName, resourceName)
   784  	if err != nil {
   785  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterAdminCredentials", nil, "Failure preparing request")
   786  		return
   787  	}
   788  
   789  	resp, err := client.ListClusterAdminCredentialsSender(req)
   790  	if err != nil {
   791  		result.Response = autorest.Response{Response: resp}
   792  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterAdminCredentials", resp, "Failure sending request")
   793  		return
   794  	}
   795  
   796  	result, err = client.ListClusterAdminCredentialsResponder(resp)
   797  	if err != nil {
   798  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterAdminCredentials", resp, "Failure responding to request")
   799  		return
   800  	}
   801  
   802  	return
   803  }
   804  
   805  // ListClusterAdminCredentialsPreparer prepares the ListClusterAdminCredentials request.
   806  func (client ManagedClustersClient) ListClusterAdminCredentialsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   807  	pathParameters := map[string]interface{}{
   808  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   809  		"resourceName":      autorest.Encode("path", resourceName),
   810  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   811  	}
   812  
   813  	const APIVersion = "2020-09-01"
   814  	queryParameters := map[string]interface{}{
   815  		"api-version": APIVersion,
   816  	}
   817  
   818  	preparer := autorest.CreatePreparer(
   819  		autorest.AsPost(),
   820  		autorest.WithBaseURL(client.BaseURI),
   821  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/listClusterAdminCredential", pathParameters),
   822  		autorest.WithQueryParameters(queryParameters))
   823  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   824  }
   825  
   826  // ListClusterAdminCredentialsSender sends the ListClusterAdminCredentials request. The method will close the
   827  // http.Response Body if it receives an error.
   828  func (client ManagedClustersClient) ListClusterAdminCredentialsSender(req *http.Request) (*http.Response, error) {
   829  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   830  }
   831  
   832  // ListClusterAdminCredentialsResponder handles the response to the ListClusterAdminCredentials request. The method always
   833  // closes the http.Response Body.
   834  func (client ManagedClustersClient) ListClusterAdminCredentialsResponder(resp *http.Response) (result CredentialResults, err error) {
   835  	err = autorest.Respond(
   836  		resp,
   837  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   838  		autorest.ByUnmarshallingJSON(&result),
   839  		autorest.ByClosing())
   840  	result.Response = autorest.Response{Response: resp}
   841  	return
   842  }
   843  
   844  // ListClusterMonitoringUserCredentials gets cluster monitoring user credential of the managed cluster with a specified
   845  // resource group and name.
   846  // Parameters:
   847  // resourceGroupName - the name of the resource group.
   848  // resourceName - the name of the managed cluster resource.
   849  func (client ManagedClustersClient) ListClusterMonitoringUserCredentials(ctx context.Context, resourceGroupName string, resourceName string) (result CredentialResults, err error) {
   850  	if tracing.IsEnabled() {
   851  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.ListClusterMonitoringUserCredentials")
   852  		defer func() {
   853  			sc := -1
   854  			if result.Response.Response != nil {
   855  				sc = result.Response.Response.StatusCode
   856  			}
   857  			tracing.EndSpan(ctx, sc, err)
   858  		}()
   859  	}
   860  	if err := validation.Validate([]validation.Validation{
   861  		{TargetValue: resourceGroupName,
   862  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   863  		{TargetValue: resourceName,
   864  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
   865  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
   866  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   867  		return result, validation.NewError("containerservice.ManagedClustersClient", "ListClusterMonitoringUserCredentials", err.Error())
   868  	}
   869  
   870  	req, err := client.ListClusterMonitoringUserCredentialsPreparer(ctx, resourceGroupName, resourceName)
   871  	if err != nil {
   872  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterMonitoringUserCredentials", nil, "Failure preparing request")
   873  		return
   874  	}
   875  
   876  	resp, err := client.ListClusterMonitoringUserCredentialsSender(req)
   877  	if err != nil {
   878  		result.Response = autorest.Response{Response: resp}
   879  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterMonitoringUserCredentials", resp, "Failure sending request")
   880  		return
   881  	}
   882  
   883  	result, err = client.ListClusterMonitoringUserCredentialsResponder(resp)
   884  	if err != nil {
   885  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterMonitoringUserCredentials", resp, "Failure responding to request")
   886  		return
   887  	}
   888  
   889  	return
   890  }
   891  
   892  // ListClusterMonitoringUserCredentialsPreparer prepares the ListClusterMonitoringUserCredentials request.
   893  func (client ManagedClustersClient) ListClusterMonitoringUserCredentialsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   894  	pathParameters := map[string]interface{}{
   895  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   896  		"resourceName":      autorest.Encode("path", resourceName),
   897  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   898  	}
   899  
   900  	const APIVersion = "2020-09-01"
   901  	queryParameters := map[string]interface{}{
   902  		"api-version": APIVersion,
   903  	}
   904  
   905  	preparer := autorest.CreatePreparer(
   906  		autorest.AsPost(),
   907  		autorest.WithBaseURL(client.BaseURI),
   908  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/listClusterMonitoringUserCredential", pathParameters),
   909  		autorest.WithQueryParameters(queryParameters))
   910  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   911  }
   912  
   913  // ListClusterMonitoringUserCredentialsSender sends the ListClusterMonitoringUserCredentials request. The method will close the
   914  // http.Response Body if it receives an error.
   915  func (client ManagedClustersClient) ListClusterMonitoringUserCredentialsSender(req *http.Request) (*http.Response, error) {
   916  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   917  }
   918  
   919  // ListClusterMonitoringUserCredentialsResponder handles the response to the ListClusterMonitoringUserCredentials request. The method always
   920  // closes the http.Response Body.
   921  func (client ManagedClustersClient) ListClusterMonitoringUserCredentialsResponder(resp *http.Response) (result CredentialResults, err error) {
   922  	err = autorest.Respond(
   923  		resp,
   924  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   925  		autorest.ByUnmarshallingJSON(&result),
   926  		autorest.ByClosing())
   927  	result.Response = autorest.Response{Response: resp}
   928  	return
   929  }
   930  
   931  // ListClusterUserCredentials gets cluster user credential of the managed cluster with a specified resource group and
   932  // name.
   933  // Parameters:
   934  // resourceGroupName - the name of the resource group.
   935  // resourceName - the name of the managed cluster resource.
   936  func (client ManagedClustersClient) ListClusterUserCredentials(ctx context.Context, resourceGroupName string, resourceName string) (result CredentialResults, err error) {
   937  	if tracing.IsEnabled() {
   938  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.ListClusterUserCredentials")
   939  		defer func() {
   940  			sc := -1
   941  			if result.Response.Response != nil {
   942  				sc = result.Response.Response.StatusCode
   943  			}
   944  			tracing.EndSpan(ctx, sc, err)
   945  		}()
   946  	}
   947  	if err := validation.Validate([]validation.Validation{
   948  		{TargetValue: resourceGroupName,
   949  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
   950  		{TargetValue: resourceName,
   951  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
   952  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
   953  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   954  		return result, validation.NewError("containerservice.ManagedClustersClient", "ListClusterUserCredentials", err.Error())
   955  	}
   956  
   957  	req, err := client.ListClusterUserCredentialsPreparer(ctx, resourceGroupName, resourceName)
   958  	if err != nil {
   959  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterUserCredentials", nil, "Failure preparing request")
   960  		return
   961  	}
   962  
   963  	resp, err := client.ListClusterUserCredentialsSender(req)
   964  	if err != nil {
   965  		result.Response = autorest.Response{Response: resp}
   966  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterUserCredentials", resp, "Failure sending request")
   967  		return
   968  	}
   969  
   970  	result, err = client.ListClusterUserCredentialsResponder(resp)
   971  	if err != nil {
   972  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ListClusterUserCredentials", resp, "Failure responding to request")
   973  		return
   974  	}
   975  
   976  	return
   977  }
   978  
   979  // ListClusterUserCredentialsPreparer prepares the ListClusterUserCredentials request.
   980  func (client ManagedClustersClient) ListClusterUserCredentialsPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
   981  	pathParameters := map[string]interface{}{
   982  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   983  		"resourceName":      autorest.Encode("path", resourceName),
   984  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   985  	}
   986  
   987  	const APIVersion = "2020-09-01"
   988  	queryParameters := map[string]interface{}{
   989  		"api-version": APIVersion,
   990  	}
   991  
   992  	preparer := autorest.CreatePreparer(
   993  		autorest.AsPost(),
   994  		autorest.WithBaseURL(client.BaseURI),
   995  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/listClusterUserCredential", pathParameters),
   996  		autorest.WithQueryParameters(queryParameters))
   997  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   998  }
   999  
  1000  // ListClusterUserCredentialsSender sends the ListClusterUserCredentials request. The method will close the
  1001  // http.Response Body if it receives an error.
  1002  func (client ManagedClustersClient) ListClusterUserCredentialsSender(req *http.Request) (*http.Response, error) {
  1003  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1004  }
  1005  
  1006  // ListClusterUserCredentialsResponder handles the response to the ListClusterUserCredentials request. The method always
  1007  // closes the http.Response Body.
  1008  func (client ManagedClustersClient) ListClusterUserCredentialsResponder(resp *http.Response) (result CredentialResults, err error) {
  1009  	err = autorest.Respond(
  1010  		resp,
  1011  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1012  		autorest.ByUnmarshallingJSON(&result),
  1013  		autorest.ByClosing())
  1014  	result.Response = autorest.Response{Response: resp}
  1015  	return
  1016  }
  1017  
  1018  // ResetAADProfile update the AAD Profile for a managed cluster.
  1019  // Parameters:
  1020  // resourceGroupName - the name of the resource group.
  1021  // resourceName - the name of the managed cluster resource.
  1022  // parameters - parameters supplied to the Reset AAD Profile operation for a Managed Cluster.
  1023  func (client ManagedClustersClient) ResetAADProfile(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedClusterAADProfile) (result ManagedClustersResetAADProfileFuture, err error) {
  1024  	if tracing.IsEnabled() {
  1025  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.ResetAADProfile")
  1026  		defer func() {
  1027  			sc := -1
  1028  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1029  				sc = result.FutureAPI.Response().StatusCode
  1030  			}
  1031  			tracing.EndSpan(ctx, sc, err)
  1032  		}()
  1033  	}
  1034  	if err := validation.Validate([]validation.Validation{
  1035  		{TargetValue: resourceGroupName,
  1036  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1037  		{TargetValue: resourceName,
  1038  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
  1039  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1040  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
  1041  		return result, validation.NewError("containerservice.ManagedClustersClient", "ResetAADProfile", err.Error())
  1042  	}
  1043  
  1044  	req, err := client.ResetAADProfilePreparer(ctx, resourceGroupName, resourceName, parameters)
  1045  	if err != nil {
  1046  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ResetAADProfile", nil, "Failure preparing request")
  1047  		return
  1048  	}
  1049  
  1050  	result, err = client.ResetAADProfileSender(req)
  1051  	if err != nil {
  1052  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ResetAADProfile", result.Response(), "Failure sending request")
  1053  		return
  1054  	}
  1055  
  1056  	return
  1057  }
  1058  
  1059  // ResetAADProfilePreparer prepares the ResetAADProfile request.
  1060  func (client ManagedClustersClient) ResetAADProfilePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedClusterAADProfile) (*http.Request, error) {
  1061  	pathParameters := map[string]interface{}{
  1062  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1063  		"resourceName":      autorest.Encode("path", resourceName),
  1064  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1065  	}
  1066  
  1067  	const APIVersion = "2020-09-01"
  1068  	queryParameters := map[string]interface{}{
  1069  		"api-version": APIVersion,
  1070  	}
  1071  
  1072  	preparer := autorest.CreatePreparer(
  1073  		autorest.AsContentType("application/json; charset=utf-8"),
  1074  		autorest.AsPost(),
  1075  		autorest.WithBaseURL(client.BaseURI),
  1076  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/resetAADProfile", pathParameters),
  1077  		autorest.WithJSON(parameters),
  1078  		autorest.WithQueryParameters(queryParameters))
  1079  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1080  }
  1081  
  1082  // ResetAADProfileSender sends the ResetAADProfile request. The method will close the
  1083  // http.Response Body if it receives an error.
  1084  func (client ManagedClustersClient) ResetAADProfileSender(req *http.Request) (future ManagedClustersResetAADProfileFuture, err error) {
  1085  	var resp *http.Response
  1086  	future.FutureAPI = &azure.Future{}
  1087  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1088  	if err != nil {
  1089  		return
  1090  	}
  1091  	var azf azure.Future
  1092  	azf, err = azure.NewFutureFromResponse(resp)
  1093  	future.FutureAPI = &azf
  1094  	future.Result = future.result
  1095  	return
  1096  }
  1097  
  1098  // ResetAADProfileResponder handles the response to the ResetAADProfile request. The method always
  1099  // closes the http.Response Body.
  1100  func (client ManagedClustersClient) ResetAADProfileResponder(resp *http.Response) (result autorest.Response, err error) {
  1101  	err = autorest.Respond(
  1102  		resp,
  1103  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1104  		autorest.ByClosing())
  1105  	result.Response = resp
  1106  	return
  1107  }
  1108  
  1109  // ResetServicePrincipalProfile update the service principal Profile for a managed cluster.
  1110  // Parameters:
  1111  // resourceGroupName - the name of the resource group.
  1112  // resourceName - the name of the managed cluster resource.
  1113  // parameters - parameters supplied to the Reset Service Principal Profile operation for a Managed Cluster.
  1114  func (client ManagedClustersClient) ResetServicePrincipalProfile(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedClusterServicePrincipalProfile) (result ManagedClustersResetServicePrincipalProfileFuture, err error) {
  1115  	if tracing.IsEnabled() {
  1116  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.ResetServicePrincipalProfile")
  1117  		defer func() {
  1118  			sc := -1
  1119  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1120  				sc = result.FutureAPI.Response().StatusCode
  1121  			}
  1122  			tracing.EndSpan(ctx, sc, err)
  1123  		}()
  1124  	}
  1125  	if err := validation.Validate([]validation.Validation{
  1126  		{TargetValue: resourceGroupName,
  1127  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1128  		{TargetValue: resourceName,
  1129  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
  1130  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1131  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}},
  1132  		{TargetValue: parameters,
  1133  			Constraints: []validation.Constraint{{Target: "parameters.ClientID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil {
  1134  		return result, validation.NewError("containerservice.ManagedClustersClient", "ResetServicePrincipalProfile", err.Error())
  1135  	}
  1136  
  1137  	req, err := client.ResetServicePrincipalProfilePreparer(ctx, resourceGroupName, resourceName, parameters)
  1138  	if err != nil {
  1139  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ResetServicePrincipalProfile", nil, "Failure preparing request")
  1140  		return
  1141  	}
  1142  
  1143  	result, err = client.ResetServicePrincipalProfileSender(req)
  1144  	if err != nil {
  1145  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "ResetServicePrincipalProfile", result.Response(), "Failure sending request")
  1146  		return
  1147  	}
  1148  
  1149  	return
  1150  }
  1151  
  1152  // ResetServicePrincipalProfilePreparer prepares the ResetServicePrincipalProfile request.
  1153  func (client ManagedClustersClient) ResetServicePrincipalProfilePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedClusterServicePrincipalProfile) (*http.Request, error) {
  1154  	pathParameters := map[string]interface{}{
  1155  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1156  		"resourceName":      autorest.Encode("path", resourceName),
  1157  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1158  	}
  1159  
  1160  	const APIVersion = "2020-09-01"
  1161  	queryParameters := map[string]interface{}{
  1162  		"api-version": APIVersion,
  1163  	}
  1164  
  1165  	preparer := autorest.CreatePreparer(
  1166  		autorest.AsContentType("application/json; charset=utf-8"),
  1167  		autorest.AsPost(),
  1168  		autorest.WithBaseURL(client.BaseURI),
  1169  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/resetServicePrincipalProfile", pathParameters),
  1170  		autorest.WithJSON(parameters),
  1171  		autorest.WithQueryParameters(queryParameters))
  1172  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1173  }
  1174  
  1175  // ResetServicePrincipalProfileSender sends the ResetServicePrincipalProfile request. The method will close the
  1176  // http.Response Body if it receives an error.
  1177  func (client ManagedClustersClient) ResetServicePrincipalProfileSender(req *http.Request) (future ManagedClustersResetServicePrincipalProfileFuture, err error) {
  1178  	var resp *http.Response
  1179  	future.FutureAPI = &azure.Future{}
  1180  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1181  	if err != nil {
  1182  		return
  1183  	}
  1184  	var azf azure.Future
  1185  	azf, err = azure.NewFutureFromResponse(resp)
  1186  	future.FutureAPI = &azf
  1187  	future.Result = future.result
  1188  	return
  1189  }
  1190  
  1191  // ResetServicePrincipalProfileResponder handles the response to the ResetServicePrincipalProfile request. The method always
  1192  // closes the http.Response Body.
  1193  func (client ManagedClustersClient) ResetServicePrincipalProfileResponder(resp *http.Response) (result autorest.Response, err error) {
  1194  	err = autorest.Respond(
  1195  		resp,
  1196  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
  1197  		autorest.ByClosing())
  1198  	result.Response = resp
  1199  	return
  1200  }
  1201  
  1202  // RotateClusterCertificates rotate certificates of a managed cluster.
  1203  // Parameters:
  1204  // resourceGroupName - the name of the resource group.
  1205  // resourceName - the name of the managed cluster resource.
  1206  func (client ManagedClustersClient) RotateClusterCertificates(ctx context.Context, resourceGroupName string, resourceName string) (result ManagedClustersRotateClusterCertificatesFuture, err error) {
  1207  	if tracing.IsEnabled() {
  1208  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.RotateClusterCertificates")
  1209  		defer func() {
  1210  			sc := -1
  1211  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1212  				sc = result.FutureAPI.Response().StatusCode
  1213  			}
  1214  			tracing.EndSpan(ctx, sc, err)
  1215  		}()
  1216  	}
  1217  	if err := validation.Validate([]validation.Validation{
  1218  		{TargetValue: resourceGroupName,
  1219  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1220  		{TargetValue: resourceName,
  1221  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
  1222  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1223  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
  1224  		return result, validation.NewError("containerservice.ManagedClustersClient", "RotateClusterCertificates", err.Error())
  1225  	}
  1226  
  1227  	req, err := client.RotateClusterCertificatesPreparer(ctx, resourceGroupName, resourceName)
  1228  	if err != nil {
  1229  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "RotateClusterCertificates", nil, "Failure preparing request")
  1230  		return
  1231  	}
  1232  
  1233  	result, err = client.RotateClusterCertificatesSender(req)
  1234  	if err != nil {
  1235  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "RotateClusterCertificates", result.Response(), "Failure sending request")
  1236  		return
  1237  	}
  1238  
  1239  	return
  1240  }
  1241  
  1242  // RotateClusterCertificatesPreparer prepares the RotateClusterCertificates request.
  1243  func (client ManagedClustersClient) RotateClusterCertificatesPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1244  	pathParameters := map[string]interface{}{
  1245  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1246  		"resourceName":      autorest.Encode("path", resourceName),
  1247  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1248  	}
  1249  
  1250  	const APIVersion = "2020-09-01"
  1251  	queryParameters := map[string]interface{}{
  1252  		"api-version": APIVersion,
  1253  	}
  1254  
  1255  	preparer := autorest.CreatePreparer(
  1256  		autorest.AsPost(),
  1257  		autorest.WithBaseURL(client.BaseURI),
  1258  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/rotateClusterCertificates", pathParameters),
  1259  		autorest.WithQueryParameters(queryParameters))
  1260  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1261  }
  1262  
  1263  // RotateClusterCertificatesSender sends the RotateClusterCertificates request. The method will close the
  1264  // http.Response Body if it receives an error.
  1265  func (client ManagedClustersClient) RotateClusterCertificatesSender(req *http.Request) (future ManagedClustersRotateClusterCertificatesFuture, err error) {
  1266  	var resp *http.Response
  1267  	future.FutureAPI = &azure.Future{}
  1268  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1269  	if err != nil {
  1270  		return
  1271  	}
  1272  	var azf azure.Future
  1273  	azf, err = azure.NewFutureFromResponse(resp)
  1274  	future.FutureAPI = &azf
  1275  	future.Result = future.result
  1276  	return
  1277  }
  1278  
  1279  // RotateClusterCertificatesResponder handles the response to the RotateClusterCertificates request. The method always
  1280  // closes the http.Response Body.
  1281  func (client ManagedClustersClient) RotateClusterCertificatesResponder(resp *http.Response) (result autorest.Response, err error) {
  1282  	err = autorest.Respond(
  1283  		resp,
  1284  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1285  		autorest.ByClosing())
  1286  	result.Response = resp
  1287  	return
  1288  }
  1289  
  1290  // Start starts a Stopped Managed Cluster
  1291  // Parameters:
  1292  // resourceGroupName - the name of the resource group.
  1293  // resourceName - the name of the managed cluster resource.
  1294  func (client ManagedClustersClient) Start(ctx context.Context, resourceGroupName string, resourceName string) (result ManagedClustersStartFuture, err error) {
  1295  	if tracing.IsEnabled() {
  1296  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.Start")
  1297  		defer func() {
  1298  			sc := -1
  1299  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1300  				sc = result.FutureAPI.Response().StatusCode
  1301  			}
  1302  			tracing.EndSpan(ctx, sc, err)
  1303  		}()
  1304  	}
  1305  	if err := validation.Validate([]validation.Validation{
  1306  		{TargetValue: resourceGroupName,
  1307  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1308  		{TargetValue: resourceName,
  1309  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
  1310  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1311  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
  1312  		return result, validation.NewError("containerservice.ManagedClustersClient", "Start", err.Error())
  1313  	}
  1314  
  1315  	req, err := client.StartPreparer(ctx, resourceGroupName, resourceName)
  1316  	if err != nil {
  1317  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Start", nil, "Failure preparing request")
  1318  		return
  1319  	}
  1320  
  1321  	result, err = client.StartSender(req)
  1322  	if err != nil {
  1323  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Start", result.Response(), "Failure sending request")
  1324  		return
  1325  	}
  1326  
  1327  	return
  1328  }
  1329  
  1330  // StartPreparer prepares the Start request.
  1331  func (client ManagedClustersClient) StartPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1332  	pathParameters := map[string]interface{}{
  1333  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1334  		"resourceName":      autorest.Encode("path", resourceName),
  1335  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1336  	}
  1337  
  1338  	const APIVersion = "2020-09-01"
  1339  	queryParameters := map[string]interface{}{
  1340  		"api-version": APIVersion,
  1341  	}
  1342  
  1343  	preparer := autorest.CreatePreparer(
  1344  		autorest.AsPost(),
  1345  		autorest.WithBaseURL(client.BaseURI),
  1346  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/start", pathParameters),
  1347  		autorest.WithQueryParameters(queryParameters))
  1348  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1349  }
  1350  
  1351  // StartSender sends the Start request. The method will close the
  1352  // http.Response Body if it receives an error.
  1353  func (client ManagedClustersClient) StartSender(req *http.Request) (future ManagedClustersStartFuture, err error) {
  1354  	var resp *http.Response
  1355  	future.FutureAPI = &azure.Future{}
  1356  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1357  	if err != nil {
  1358  		return
  1359  	}
  1360  	var azf azure.Future
  1361  	azf, err = azure.NewFutureFromResponse(resp)
  1362  	future.FutureAPI = &azf
  1363  	future.Result = future.result
  1364  	return
  1365  }
  1366  
  1367  // StartResponder handles the response to the Start request. The method always
  1368  // closes the http.Response Body.
  1369  func (client ManagedClustersClient) StartResponder(resp *http.Response) (result autorest.Response, err error) {
  1370  	err = autorest.Respond(
  1371  		resp,
  1372  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1373  		autorest.ByClosing())
  1374  	result.Response = resp
  1375  	return
  1376  }
  1377  
  1378  // Stop stops a Running Managed Cluster
  1379  // Parameters:
  1380  // resourceGroupName - the name of the resource group.
  1381  // resourceName - the name of the managed cluster resource.
  1382  func (client ManagedClustersClient) Stop(ctx context.Context, resourceGroupName string, resourceName string) (result ManagedClustersStopFuture, err error) {
  1383  	if tracing.IsEnabled() {
  1384  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.Stop")
  1385  		defer func() {
  1386  			sc := -1
  1387  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1388  				sc = result.FutureAPI.Response().StatusCode
  1389  			}
  1390  			tracing.EndSpan(ctx, sc, err)
  1391  		}()
  1392  	}
  1393  	if err := validation.Validate([]validation.Validation{
  1394  		{TargetValue: resourceGroupName,
  1395  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1396  		{TargetValue: resourceName,
  1397  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
  1398  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1399  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
  1400  		return result, validation.NewError("containerservice.ManagedClustersClient", "Stop", err.Error())
  1401  	}
  1402  
  1403  	req, err := client.StopPreparer(ctx, resourceGroupName, resourceName)
  1404  	if err != nil {
  1405  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Stop", nil, "Failure preparing request")
  1406  		return
  1407  	}
  1408  
  1409  	result, err = client.StopSender(req)
  1410  	if err != nil {
  1411  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "Stop", result.Response(), "Failure sending request")
  1412  		return
  1413  	}
  1414  
  1415  	return
  1416  }
  1417  
  1418  // StopPreparer prepares the Stop request.
  1419  func (client ManagedClustersClient) StopPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) {
  1420  	pathParameters := map[string]interface{}{
  1421  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1422  		"resourceName":      autorest.Encode("path", resourceName),
  1423  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1424  	}
  1425  
  1426  	const APIVersion = "2020-09-01"
  1427  	queryParameters := map[string]interface{}{
  1428  		"api-version": APIVersion,
  1429  	}
  1430  
  1431  	preparer := autorest.CreatePreparer(
  1432  		autorest.AsPost(),
  1433  		autorest.WithBaseURL(client.BaseURI),
  1434  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}/stop", pathParameters),
  1435  		autorest.WithQueryParameters(queryParameters))
  1436  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1437  }
  1438  
  1439  // StopSender sends the Stop request. The method will close the
  1440  // http.Response Body if it receives an error.
  1441  func (client ManagedClustersClient) StopSender(req *http.Request) (future ManagedClustersStopFuture, err error) {
  1442  	var resp *http.Response
  1443  	future.FutureAPI = &azure.Future{}
  1444  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1445  	if err != nil {
  1446  		return
  1447  	}
  1448  	var azf azure.Future
  1449  	azf, err = azure.NewFutureFromResponse(resp)
  1450  	future.FutureAPI = &azf
  1451  	future.Result = future.result
  1452  	return
  1453  }
  1454  
  1455  // StopResponder handles the response to the Stop request. The method always
  1456  // closes the http.Response Body.
  1457  func (client ManagedClustersClient) StopResponder(resp *http.Response) (result autorest.Response, err error) {
  1458  	err = autorest.Respond(
  1459  		resp,
  1460  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
  1461  		autorest.ByClosing())
  1462  	result.Response = resp
  1463  	return
  1464  }
  1465  
  1466  // UpdateTags updates a managed cluster with the specified tags.
  1467  // Parameters:
  1468  // resourceGroupName - the name of the resource group.
  1469  // resourceName - the name of the managed cluster resource.
  1470  // parameters - parameters supplied to the Update Managed Cluster Tags operation.
  1471  func (client ManagedClustersClient) UpdateTags(ctx context.Context, resourceGroupName string, resourceName string, parameters TagsObject) (result ManagedClustersUpdateTagsFuture, err error) {
  1472  	if tracing.IsEnabled() {
  1473  		ctx = tracing.StartSpan(ctx, fqdn+"/ManagedClustersClient.UpdateTags")
  1474  		defer func() {
  1475  			sc := -1
  1476  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
  1477  				sc = result.FutureAPI.Response().StatusCode
  1478  			}
  1479  			tracing.EndSpan(ctx, sc, err)
  1480  		}()
  1481  	}
  1482  	if err := validation.Validate([]validation.Validation{
  1483  		{TargetValue: resourceGroupName,
  1484  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}}},
  1485  		{TargetValue: resourceName,
  1486  			Constraints: []validation.Constraint{{Target: "resourceName", Name: validation.MaxLength, Rule: 63, Chain: nil},
  1487  				{Target: "resourceName", Name: validation.MinLength, Rule: 1, Chain: nil},
  1488  				{Target: "resourceName", Name: validation.Pattern, Rule: `^[a-zA-Z0-9]$|^[a-zA-Z0-9][-_a-zA-Z0-9]{0,61}[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
  1489  		return result, validation.NewError("containerservice.ManagedClustersClient", "UpdateTags", err.Error())
  1490  	}
  1491  
  1492  	req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, resourceName, parameters)
  1493  	if err != nil {
  1494  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "UpdateTags", nil, "Failure preparing request")
  1495  		return
  1496  	}
  1497  
  1498  	result, err = client.UpdateTagsSender(req)
  1499  	if err != nil {
  1500  		err = autorest.NewErrorWithError(err, "containerservice.ManagedClustersClient", "UpdateTags", result.Response(), "Failure sending request")
  1501  		return
  1502  	}
  1503  
  1504  	return
  1505  }
  1506  
  1507  // UpdateTagsPreparer prepares the UpdateTags request.
  1508  func (client ManagedClustersClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters TagsObject) (*http.Request, error) {
  1509  	pathParameters := map[string]interface{}{
  1510  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
  1511  		"resourceName":      autorest.Encode("path", resourceName),
  1512  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
  1513  	}
  1514  
  1515  	const APIVersion = "2020-09-01"
  1516  	queryParameters := map[string]interface{}{
  1517  		"api-version": APIVersion,
  1518  	}
  1519  
  1520  	preparer := autorest.CreatePreparer(
  1521  		autorest.AsContentType("application/json; charset=utf-8"),
  1522  		autorest.AsPatch(),
  1523  		autorest.WithBaseURL(client.BaseURI),
  1524  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/managedClusters/{resourceName}", pathParameters),
  1525  		autorest.WithJSON(parameters),
  1526  		autorest.WithQueryParameters(queryParameters))
  1527  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
  1528  }
  1529  
  1530  // UpdateTagsSender sends the UpdateTags request. The method will close the
  1531  // http.Response Body if it receives an error.
  1532  func (client ManagedClustersClient) UpdateTagsSender(req *http.Request) (future ManagedClustersUpdateTagsFuture, err error) {
  1533  	var resp *http.Response
  1534  	future.FutureAPI = &azure.Future{}
  1535  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
  1536  	if err != nil {
  1537  		return
  1538  	}
  1539  	var azf azure.Future
  1540  	azf, err = azure.NewFutureFromResponse(resp)
  1541  	future.FutureAPI = &azf
  1542  	future.Result = future.result
  1543  	return
  1544  }
  1545  
  1546  // UpdateTagsResponder handles the response to the UpdateTags request. The method always
  1547  // closes the http.Response Body.
  1548  func (client ManagedClustersClient) UpdateTagsResponder(resp *http.Response) (result ManagedCluster, err error) {
  1549  	err = autorest.Respond(
  1550  		resp,
  1551  		azure.WithErrorUnlessStatusCode(http.StatusOK),
  1552  		autorest.ByUnmarshallingJSON(&result),
  1553  		autorest.ByClosing())
  1554  	result.Response = autorest.Response{Response: resp}
  1555  	return
  1556  }
  1557  

View as plain text