operationalizationclusters.go

Documentation: github.com/Azure/azure-sdk-for-go/services/preview/machinelearning/mgmt/2017-08-01-preview/compute

     1  package compute
     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  // OperationalizationClustersClient is the these APIs allow end users to operate on Azure Machine Learning Compute
    19  // resources. They support the following operations:<ul><li>Create or update a cluster</li><li>Get a
    20  // cluster</li><li>Patch a cluster</li><li>Delete a cluster</li><li>Get keys for a cluster</li><li>Check if updates are
    21  // available for system services in a cluster</li><li>Update system services in a cluster</li><li>Get all clusters in a
    22  // resource group</li><li>Get all clusters in a subscription</li></ul>
    23  type OperationalizationClustersClient struct {
    24  	BaseClient
    25  }
    26  
    27  // NewOperationalizationClustersClient creates an instance of the OperationalizationClustersClient client.
    28  func NewOperationalizationClustersClient(subscriptionID string) OperationalizationClustersClient {
    29  	return NewOperationalizationClustersClientWithBaseURI(DefaultBaseURI, subscriptionID)
    30  }
    31  
    32  // NewOperationalizationClustersClientWithBaseURI creates an instance of the OperationalizationClustersClient client
    33  // using a custom endpoint.  Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign
    34  // clouds, Azure stack).
    35  func NewOperationalizationClustersClientWithBaseURI(baseURI string, subscriptionID string) OperationalizationClustersClient {
    36  	return OperationalizationClustersClient{NewWithBaseURI(baseURI, subscriptionID)}
    37  }
    38  
    39  // CheckSystemServicesUpdatesAvailable checks if updates are available for system services in the cluster.
    40  // Parameters:
    41  // resourceGroupName - name of the resource group in which the cluster is located.
    42  // clusterName - the name of the cluster.
    43  func (client OperationalizationClustersClient) CheckSystemServicesUpdatesAvailable(ctx context.Context, resourceGroupName string, clusterName string) (result CheckSystemServicesUpdatesAvailableResponse, err error) {
    44  	if tracing.IsEnabled() {
    45  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.CheckSystemServicesUpdatesAvailable")
    46  		defer func() {
    47  			sc := -1
    48  			if result.Response.Response != nil {
    49  				sc = result.Response.Response.StatusCode
    50  			}
    51  			tracing.EndSpan(ctx, sc, err)
    52  		}()
    53  	}
    54  	if err := validation.Validate([]validation.Validation{
    55  		{TargetValue: resourceGroupName,
    56  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
    57  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
    58  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
    59  		{TargetValue: clusterName,
    60  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 90, Chain: nil},
    61  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
    62  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z][-\w\._\(\)]+[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
    63  		return result, validation.NewError("compute.OperationalizationClustersClient", "CheckSystemServicesUpdatesAvailable", err.Error())
    64  	}
    65  
    66  	req, err := client.CheckSystemServicesUpdatesAvailablePreparer(ctx, resourceGroupName, clusterName)
    67  	if err != nil {
    68  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "CheckSystemServicesUpdatesAvailable", nil, "Failure preparing request")
    69  		return
    70  	}
    71  
    72  	resp, err := client.CheckSystemServicesUpdatesAvailableSender(req)
    73  	if err != nil {
    74  		result.Response = autorest.Response{Response: resp}
    75  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "CheckSystemServicesUpdatesAvailable", resp, "Failure sending request")
    76  		return
    77  	}
    78  
    79  	result, err = client.CheckSystemServicesUpdatesAvailableResponder(resp)
    80  	if err != nil {
    81  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "CheckSystemServicesUpdatesAvailable", resp, "Failure responding to request")
    82  		return
    83  	}
    84  
    85  	return
    86  }
    87  
    88  // CheckSystemServicesUpdatesAvailablePreparer prepares the CheckSystemServicesUpdatesAvailable request.
    89  func (client OperationalizationClustersClient) CheckSystemServicesUpdatesAvailablePreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) {
    90  	pathParameters := map[string]interface{}{
    91  		"clusterName":       autorest.Encode("path", clusterName),
    92  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
    93  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
    94  	}
    95  
    96  	const APIVersion = "2017-08-01-preview"
    97  	queryParameters := map[string]interface{}{
    98  		"api-version": APIVersion,
    99  	}
   100  
   101  	preparer := autorest.CreatePreparer(
   102  		autorest.AsPost(),
   103  		autorest.WithBaseURL(client.BaseURI),
   104  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningCompute/operationalizationClusters/{clusterName}/checkSystemServicesUpdatesAvailable", pathParameters),
   105  		autorest.WithQueryParameters(queryParameters))
   106  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   107  }
   108  
   109  // CheckSystemServicesUpdatesAvailableSender sends the CheckSystemServicesUpdatesAvailable request. The method will close the
   110  // http.Response Body if it receives an error.
   111  func (client OperationalizationClustersClient) CheckSystemServicesUpdatesAvailableSender(req *http.Request) (*http.Response, error) {
   112  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   113  }
   114  
   115  // CheckSystemServicesUpdatesAvailableResponder handles the response to the CheckSystemServicesUpdatesAvailable request. The method always
   116  // closes the http.Response Body.
   117  func (client OperationalizationClustersClient) CheckSystemServicesUpdatesAvailableResponder(resp *http.Response) (result CheckSystemServicesUpdatesAvailableResponse, err error) {
   118  	err = autorest.Respond(
   119  		resp,
   120  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   121  		autorest.ByUnmarshallingJSON(&result),
   122  		autorest.ByClosing())
   123  	result.Response = autorest.Response{Response: resp}
   124  	return
   125  }
   126  
   127  // CreateOrUpdate create or update an operationalization cluster.
   128  // Parameters:
   129  // resourceGroupName - name of the resource group in which the cluster is located.
   130  // clusterName - the name of the cluster.
   131  // parameters - parameters supplied to create or update an Operationalization cluster.
   132  func (client OperationalizationClustersClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, clusterName string, parameters OperationalizationCluster) (result OperationalizationClustersCreateOrUpdateFuture, err error) {
   133  	if tracing.IsEnabled() {
   134  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.CreateOrUpdate")
   135  		defer func() {
   136  			sc := -1
   137  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   138  				sc = result.FutureAPI.Response().StatusCode
   139  			}
   140  			tracing.EndSpan(ctx, sc, err)
   141  		}()
   142  	}
   143  	if err := validation.Validate([]validation.Validation{
   144  		{TargetValue: resourceGroupName,
   145  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   146  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   147  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   148  		{TargetValue: clusterName,
   149  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   150  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   151  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z][-\w\._\(\)]+[a-zA-Z0-9]$`, Chain: nil}}},
   152  		{TargetValue: parameters,
   153  			Constraints: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties", Name: validation.Null, Rule: false,
   154  				Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.ContainerService", Name: validation.Null, Rule: false,
   155  					Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.ContainerService.OrchestratorProperties", Name: validation.Null, Rule: false,
   156  						Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.ContainerService.OrchestratorProperties.ServicePrincipal", Name: validation.Null, Rule: false,
   157  							Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.ContainerService.OrchestratorProperties.ServicePrincipal.ClientID", Name: validation.Null, Rule: true, Chain: nil},
   158  								{Target: "parameters.OperationalizationClusterProperties.ContainerService.OrchestratorProperties.ServicePrincipal.Secret", Name: validation.Null, Rule: true, Chain: nil},
   159  							}},
   160  						}},
   161  						{Target: "parameters.OperationalizationClusterProperties.ContainerService.MasterCount", Name: validation.Null, Rule: false,
   162  							Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.ContainerService.MasterCount", Name: validation.InclusiveMaximum, Rule: int64(5), Chain: nil},
   163  								{Target: "parameters.OperationalizationClusterProperties.ContainerService.MasterCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   164  							}},
   165  						{Target: "parameters.OperationalizationClusterProperties.ContainerService.AgentCount", Name: validation.Null, Rule: false,
   166  							Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.ContainerService.AgentCount", Name: validation.InclusiveMaximum, Rule: int64(100), Chain: nil},
   167  								{Target: "parameters.OperationalizationClusterProperties.ContainerService.AgentCount", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil},
   168  							}},
   169  					}},
   170  					{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration", Name: validation.Null, Rule: false,
   171  						Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration.ServiceAuth", Name: validation.Null, Rule: false,
   172  							Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration.ServiceAuth.PrimaryAuthKeyHash", Name: validation.Null, Rule: true, Chain: nil},
   173  								{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration.ServiceAuth.SecondaryAuthKeyHash", Name: validation.Null, Rule: true, Chain: nil},
   174  							}},
   175  							{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration.AutoScale", Name: validation.Null, Rule: false,
   176  								Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration.AutoScale.MinReplicas", Name: validation.Null, Rule: false,
   177  									Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration.AutoScale.MinReplicas", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
   178  									{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration.AutoScale.MaxReplicas", Name: validation.Null, Rule: false,
   179  										Chain: []validation.Constraint{{Target: "parameters.OperationalizationClusterProperties.GlobalServiceConfiguration.AutoScale.MaxReplicas", Name: validation.InclusiveMinimum, Rule: int64(1), Chain: nil}}},
   180  								}},
   181  						}},
   182  				}}}}}); err != nil {
   183  		return result, validation.NewError("compute.OperationalizationClustersClient", "CreateOrUpdate", err.Error())
   184  	}
   185  
   186  	req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, clusterName, parameters)
   187  	if err != nil {
   188  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "CreateOrUpdate", nil, "Failure preparing request")
   189  		return
   190  	}
   191  
   192  	result, err = client.CreateOrUpdateSender(req)
   193  	if err != nil {
   194  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "CreateOrUpdate", result.Response(), "Failure sending request")
   195  		return
   196  	}
   197  
   198  	return
   199  }
   200  
   201  // CreateOrUpdatePreparer prepares the CreateOrUpdate request.
   202  func (client OperationalizationClustersClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, parameters OperationalizationCluster) (*http.Request, error) {
   203  	pathParameters := map[string]interface{}{
   204  		"clusterName":       autorest.Encode("path", clusterName),
   205  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   206  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   207  	}
   208  
   209  	const APIVersion = "2017-08-01-preview"
   210  	queryParameters := map[string]interface{}{
   211  		"api-version": APIVersion,
   212  	}
   213  
   214  	preparer := autorest.CreatePreparer(
   215  		autorest.AsContentType("application/json; charset=utf-8"),
   216  		autorest.AsPut(),
   217  		autorest.WithBaseURL(client.BaseURI),
   218  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningCompute/operationalizationClusters/{clusterName}", pathParameters),
   219  		autorest.WithJSON(parameters),
   220  		autorest.WithQueryParameters(queryParameters))
   221  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   222  }
   223  
   224  // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
   225  // http.Response Body if it receives an error.
   226  func (client OperationalizationClustersClient) CreateOrUpdateSender(req *http.Request) (future OperationalizationClustersCreateOrUpdateFuture, err error) {
   227  	var resp *http.Response
   228  	future.FutureAPI = &azure.Future{}
   229  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   230  	if err != nil {
   231  		return
   232  	}
   233  	var azf azure.Future
   234  	azf, err = azure.NewFutureFromResponse(resp)
   235  	future.FutureAPI = &azf
   236  	future.Result = future.result
   237  	return
   238  }
   239  
   240  // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always
   241  // closes the http.Response Body.
   242  func (client OperationalizationClustersClient) CreateOrUpdateResponder(resp *http.Response) (result OperationalizationCluster, err error) {
   243  	err = autorest.Respond(
   244  		resp,
   245  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
   246  		autorest.ByUnmarshallingJSON(&result),
   247  		autorest.ByClosing())
   248  	result.Response = autorest.Response{Response: resp}
   249  	return
   250  }
   251  
   252  // Delete deletes the specified cluster.
   253  // Parameters:
   254  // resourceGroupName - name of the resource group in which the cluster is located.
   255  // clusterName - the name of the cluster.
   256  // deleteAll - if true, deletes all resources associated with this cluster.
   257  func (client OperationalizationClustersClient) Delete(ctx context.Context, resourceGroupName string, clusterName string, deleteAll *bool) (result OperationalizationClustersDeleteFuture, err error) {
   258  	if tracing.IsEnabled() {
   259  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.Delete")
   260  		defer func() {
   261  			sc := -1
   262  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   263  				sc = result.FutureAPI.Response().StatusCode
   264  			}
   265  			tracing.EndSpan(ctx, sc, err)
   266  		}()
   267  	}
   268  	if err := validation.Validate([]validation.Validation{
   269  		{TargetValue: resourceGroupName,
   270  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   271  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   272  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   273  		{TargetValue: clusterName,
   274  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   275  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   276  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z][-\w\._\(\)]+[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   277  		return result, validation.NewError("compute.OperationalizationClustersClient", "Delete", err.Error())
   278  	}
   279  
   280  	req, err := client.DeletePreparer(ctx, resourceGroupName, clusterName, deleteAll)
   281  	if err != nil {
   282  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "Delete", nil, "Failure preparing request")
   283  		return
   284  	}
   285  
   286  	result, err = client.DeleteSender(req)
   287  	if err != nil {
   288  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "Delete", result.Response(), "Failure sending request")
   289  		return
   290  	}
   291  
   292  	return
   293  }
   294  
   295  // DeletePreparer prepares the Delete request.
   296  func (client OperationalizationClustersClient) DeletePreparer(ctx context.Context, resourceGroupName string, clusterName string, deleteAll *bool) (*http.Request, error) {
   297  	pathParameters := map[string]interface{}{
   298  		"clusterName":       autorest.Encode("path", clusterName),
   299  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   300  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   301  	}
   302  
   303  	const APIVersion = "2017-08-01-preview"
   304  	queryParameters := map[string]interface{}{
   305  		"api-version": APIVersion,
   306  	}
   307  	if deleteAll != nil {
   308  		queryParameters["deleteAll"] = autorest.Encode("query", *deleteAll)
   309  	}
   310  
   311  	preparer := autorest.CreatePreparer(
   312  		autorest.AsDelete(),
   313  		autorest.WithBaseURL(client.BaseURI),
   314  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningCompute/operationalizationClusters/{clusterName}", pathParameters),
   315  		autorest.WithQueryParameters(queryParameters))
   316  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   317  }
   318  
   319  // DeleteSender sends the Delete request. The method will close the
   320  // http.Response Body if it receives an error.
   321  func (client OperationalizationClustersClient) DeleteSender(req *http.Request) (future OperationalizationClustersDeleteFuture, err error) {
   322  	var resp *http.Response
   323  	future.FutureAPI = &azure.Future{}
   324  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   325  	if err != nil {
   326  		return
   327  	}
   328  	var azf azure.Future
   329  	azf, err = azure.NewFutureFromResponse(resp)
   330  	future.FutureAPI = &azf
   331  	future.Result = future.result
   332  	return
   333  }
   334  
   335  // DeleteResponder handles the response to the Delete request. The method always
   336  // closes the http.Response Body.
   337  func (client OperationalizationClustersClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
   338  	err = autorest.Respond(
   339  		resp,
   340  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
   341  		autorest.ByClosing())
   342  	result.Response = resp
   343  	return
   344  }
   345  
   346  // Get gets the operationalization cluster resource view. Note that the credentials are not returned by this call. Call
   347  // ListKeys to get them.
   348  // Parameters:
   349  // resourceGroupName - name of the resource group in which the cluster is located.
   350  // clusterName - the name of the cluster.
   351  func (client OperationalizationClustersClient) Get(ctx context.Context, resourceGroupName string, clusterName string) (result OperationalizationCluster, err error) {
   352  	if tracing.IsEnabled() {
   353  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.Get")
   354  		defer func() {
   355  			sc := -1
   356  			if result.Response.Response != nil {
   357  				sc = result.Response.Response.StatusCode
   358  			}
   359  			tracing.EndSpan(ctx, sc, err)
   360  		}()
   361  	}
   362  	if err := validation.Validate([]validation.Validation{
   363  		{TargetValue: resourceGroupName,
   364  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   365  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   366  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   367  		{TargetValue: clusterName,
   368  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   369  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   370  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z][-\w\._\(\)]+[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   371  		return result, validation.NewError("compute.OperationalizationClustersClient", "Get", err.Error())
   372  	}
   373  
   374  	req, err := client.GetPreparer(ctx, resourceGroupName, clusterName)
   375  	if err != nil {
   376  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "Get", nil, "Failure preparing request")
   377  		return
   378  	}
   379  
   380  	resp, err := client.GetSender(req)
   381  	if err != nil {
   382  		result.Response = autorest.Response{Response: resp}
   383  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "Get", resp, "Failure sending request")
   384  		return
   385  	}
   386  
   387  	result, err = client.GetResponder(resp)
   388  	if err != nil {
   389  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "Get", resp, "Failure responding to request")
   390  		return
   391  	}
   392  
   393  	return
   394  }
   395  
   396  // GetPreparer prepares the Get request.
   397  func (client OperationalizationClustersClient) GetPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) {
   398  	pathParameters := map[string]interface{}{
   399  		"clusterName":       autorest.Encode("path", clusterName),
   400  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   401  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   402  	}
   403  
   404  	const APIVersion = "2017-08-01-preview"
   405  	queryParameters := map[string]interface{}{
   406  		"api-version": APIVersion,
   407  	}
   408  
   409  	preparer := autorest.CreatePreparer(
   410  		autorest.AsGet(),
   411  		autorest.WithBaseURL(client.BaseURI),
   412  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningCompute/operationalizationClusters/{clusterName}", pathParameters),
   413  		autorest.WithQueryParameters(queryParameters))
   414  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   415  }
   416  
   417  // GetSender sends the Get request. The method will close the
   418  // http.Response Body if it receives an error.
   419  func (client OperationalizationClustersClient) GetSender(req *http.Request) (*http.Response, error) {
   420  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   421  }
   422  
   423  // GetResponder handles the response to the Get request. The method always
   424  // closes the http.Response Body.
   425  func (client OperationalizationClustersClient) GetResponder(resp *http.Response) (result OperationalizationCluster, err error) {
   426  	err = autorest.Respond(
   427  		resp,
   428  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   429  		autorest.ByUnmarshallingJSON(&result),
   430  		autorest.ByClosing())
   431  	result.Response = autorest.Response{Response: resp}
   432  	return
   433  }
   434  
   435  // ListByResourceGroup gets the clusters in the specified resource group.
   436  // Parameters:
   437  // resourceGroupName - name of the resource group in which the cluster is located.
   438  // skiptoken - continuation token for pagination.
   439  func (client OperationalizationClustersClient) ListByResourceGroup(ctx context.Context, resourceGroupName string, skiptoken string) (result PaginatedOperationalizationClustersListPage, err error) {
   440  	if tracing.IsEnabled() {
   441  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.ListByResourceGroup")
   442  		defer func() {
   443  			sc := -1
   444  			if result.pocl.Response.Response != nil {
   445  				sc = result.pocl.Response.Response.StatusCode
   446  			}
   447  			tracing.EndSpan(ctx, sc, err)
   448  		}()
   449  	}
   450  	if err := validation.Validate([]validation.Validation{
   451  		{TargetValue: resourceGroupName,
   452  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   453  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   454  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil {
   455  		return result, validation.NewError("compute.OperationalizationClustersClient", "ListByResourceGroup", err.Error())
   456  	}
   457  
   458  	result.fn = client.listByResourceGroupNextResults
   459  	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName, skiptoken)
   460  	if err != nil {
   461  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListByResourceGroup", nil, "Failure preparing request")
   462  		return
   463  	}
   464  
   465  	resp, err := client.ListByResourceGroupSender(req)
   466  	if err != nil {
   467  		result.pocl.Response = autorest.Response{Response: resp}
   468  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListByResourceGroup", resp, "Failure sending request")
   469  		return
   470  	}
   471  
   472  	result.pocl, err = client.ListByResourceGroupResponder(resp)
   473  	if err != nil {
   474  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListByResourceGroup", resp, "Failure responding to request")
   475  		return
   476  	}
   477  	if result.pocl.hasNextLink() && result.pocl.IsEmpty() {
   478  		err = result.NextWithContext(ctx)
   479  		return
   480  	}
   481  
   482  	return
   483  }
   484  
   485  // ListByResourceGroupPreparer prepares the ListByResourceGroup request.
   486  func (client OperationalizationClustersClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string, skiptoken string) (*http.Request, error) {
   487  	pathParameters := map[string]interface{}{
   488  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   489  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   490  	}
   491  
   492  	const APIVersion = "2017-08-01-preview"
   493  	queryParameters := map[string]interface{}{
   494  		"api-version": APIVersion,
   495  	}
   496  	if len(skiptoken) > 0 {
   497  		queryParameters["$skiptoken"] = autorest.Encode("query", skiptoken)
   498  	}
   499  
   500  	preparer := autorest.CreatePreparer(
   501  		autorest.AsGet(),
   502  		autorest.WithBaseURL(client.BaseURI),
   503  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningCompute/operationalizationClusters", pathParameters),
   504  		autorest.WithQueryParameters(queryParameters))
   505  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   506  }
   507  
   508  // ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
   509  // http.Response Body if it receives an error.
   510  func (client OperationalizationClustersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
   511  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   512  }
   513  
   514  // ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
   515  // closes the http.Response Body.
   516  func (client OperationalizationClustersClient) ListByResourceGroupResponder(resp *http.Response) (result PaginatedOperationalizationClustersList, err error) {
   517  	err = autorest.Respond(
   518  		resp,
   519  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   520  		autorest.ByUnmarshallingJSON(&result),
   521  		autorest.ByClosing())
   522  	result.Response = autorest.Response{Response: resp}
   523  	return
   524  }
   525  
   526  // listByResourceGroupNextResults retrieves the next set of results, if any.
   527  func (client OperationalizationClustersClient) listByResourceGroupNextResults(ctx context.Context, lastResults PaginatedOperationalizationClustersList) (result PaginatedOperationalizationClustersList, err error) {
   528  	req, err := lastResults.paginatedOperationalizationClustersListPreparer(ctx)
   529  	if err != nil {
   530  		return result, autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
   531  	}
   532  	if req == nil {
   533  		return
   534  	}
   535  	resp, err := client.ListByResourceGroupSender(req)
   536  	if err != nil {
   537  		result.Response = autorest.Response{Response: resp}
   538  		return result, autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
   539  	}
   540  	result, err = client.ListByResourceGroupResponder(resp)
   541  	if err != nil {
   542  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
   543  	}
   544  	return
   545  }
   546  
   547  // ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
   548  func (client OperationalizationClustersClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string, skiptoken string) (result PaginatedOperationalizationClustersListIterator, err error) {
   549  	if tracing.IsEnabled() {
   550  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.ListByResourceGroup")
   551  		defer func() {
   552  			sc := -1
   553  			if result.Response().Response.Response != nil {
   554  				sc = result.page.Response().Response.Response.StatusCode
   555  			}
   556  			tracing.EndSpan(ctx, sc, err)
   557  		}()
   558  	}
   559  	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName, skiptoken)
   560  	return
   561  }
   562  
   563  // ListBySubscriptionID gets the operationalization clusters in the specified subscription.
   564  // Parameters:
   565  // skiptoken - continuation token for pagination.
   566  func (client OperationalizationClustersClient) ListBySubscriptionID(ctx context.Context, skiptoken string) (result PaginatedOperationalizationClustersListPage, err error) {
   567  	if tracing.IsEnabled() {
   568  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.ListBySubscriptionID")
   569  		defer func() {
   570  			sc := -1
   571  			if result.pocl.Response.Response != nil {
   572  				sc = result.pocl.Response.Response.StatusCode
   573  			}
   574  			tracing.EndSpan(ctx, sc, err)
   575  		}()
   576  	}
   577  	result.fn = client.listBySubscriptionIDNextResults
   578  	req, err := client.ListBySubscriptionIDPreparer(ctx, skiptoken)
   579  	if err != nil {
   580  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListBySubscriptionID", nil, "Failure preparing request")
   581  		return
   582  	}
   583  
   584  	resp, err := client.ListBySubscriptionIDSender(req)
   585  	if err != nil {
   586  		result.pocl.Response = autorest.Response{Response: resp}
   587  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListBySubscriptionID", resp, "Failure sending request")
   588  		return
   589  	}
   590  
   591  	result.pocl, err = client.ListBySubscriptionIDResponder(resp)
   592  	if err != nil {
   593  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListBySubscriptionID", resp, "Failure responding to request")
   594  		return
   595  	}
   596  	if result.pocl.hasNextLink() && result.pocl.IsEmpty() {
   597  		err = result.NextWithContext(ctx)
   598  		return
   599  	}
   600  
   601  	return
   602  }
   603  
   604  // ListBySubscriptionIDPreparer prepares the ListBySubscriptionID request.
   605  func (client OperationalizationClustersClient) ListBySubscriptionIDPreparer(ctx context.Context, skiptoken string) (*http.Request, error) {
   606  	pathParameters := map[string]interface{}{
   607  		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
   608  	}
   609  
   610  	const APIVersion = "2017-08-01-preview"
   611  	queryParameters := map[string]interface{}{
   612  		"api-version": APIVersion,
   613  	}
   614  	if len(skiptoken) > 0 {
   615  		queryParameters["$skiptoken"] = autorest.Encode("query", skiptoken)
   616  	}
   617  
   618  	preparer := autorest.CreatePreparer(
   619  		autorest.AsGet(),
   620  		autorest.WithBaseURL(client.BaseURI),
   621  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.MachineLearningCompute/operationalizationClusters", pathParameters),
   622  		autorest.WithQueryParameters(queryParameters))
   623  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   624  }
   625  
   626  // ListBySubscriptionIDSender sends the ListBySubscriptionID request. The method will close the
   627  // http.Response Body if it receives an error.
   628  func (client OperationalizationClustersClient) ListBySubscriptionIDSender(req *http.Request) (*http.Response, error) {
   629  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   630  }
   631  
   632  // ListBySubscriptionIDResponder handles the response to the ListBySubscriptionID request. The method always
   633  // closes the http.Response Body.
   634  func (client OperationalizationClustersClient) ListBySubscriptionIDResponder(resp *http.Response) (result PaginatedOperationalizationClustersList, err error) {
   635  	err = autorest.Respond(
   636  		resp,
   637  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   638  		autorest.ByUnmarshallingJSON(&result),
   639  		autorest.ByClosing())
   640  	result.Response = autorest.Response{Response: resp}
   641  	return
   642  }
   643  
   644  // listBySubscriptionIDNextResults retrieves the next set of results, if any.
   645  func (client OperationalizationClustersClient) listBySubscriptionIDNextResults(ctx context.Context, lastResults PaginatedOperationalizationClustersList) (result PaginatedOperationalizationClustersList, err error) {
   646  	req, err := lastResults.paginatedOperationalizationClustersListPreparer(ctx)
   647  	if err != nil {
   648  		return result, autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "listBySubscriptionIDNextResults", nil, "Failure preparing next results request")
   649  	}
   650  	if req == nil {
   651  		return
   652  	}
   653  	resp, err := client.ListBySubscriptionIDSender(req)
   654  	if err != nil {
   655  		result.Response = autorest.Response{Response: resp}
   656  		return result, autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "listBySubscriptionIDNextResults", resp, "Failure sending next results request")
   657  	}
   658  	result, err = client.ListBySubscriptionIDResponder(resp)
   659  	if err != nil {
   660  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "listBySubscriptionIDNextResults", resp, "Failure responding to next results request")
   661  	}
   662  	return
   663  }
   664  
   665  // ListBySubscriptionIDComplete enumerates all values, automatically crossing page boundaries as required.
   666  func (client OperationalizationClustersClient) ListBySubscriptionIDComplete(ctx context.Context, skiptoken string) (result PaginatedOperationalizationClustersListIterator, err error) {
   667  	if tracing.IsEnabled() {
   668  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.ListBySubscriptionID")
   669  		defer func() {
   670  			sc := -1
   671  			if result.Response().Response.Response != nil {
   672  				sc = result.page.Response().Response.Response.StatusCode
   673  			}
   674  			tracing.EndSpan(ctx, sc, err)
   675  		}()
   676  	}
   677  	result.page, err = client.ListBySubscriptionID(ctx, skiptoken)
   678  	return
   679  }
   680  
   681  // ListKeys gets the credentials for the specified cluster such as Storage, ACR and ACS credentials. This is a long
   682  // running operation because it fetches keys from dependencies.
   683  // Parameters:
   684  // resourceGroupName - name of the resource group in which the cluster is located.
   685  // clusterName - the name of the cluster.
   686  func (client OperationalizationClustersClient) ListKeys(ctx context.Context, resourceGroupName string, clusterName string) (result OperationalizationClusterCredentials, err error) {
   687  	if tracing.IsEnabled() {
   688  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.ListKeys")
   689  		defer func() {
   690  			sc := -1
   691  			if result.Response.Response != nil {
   692  				sc = result.Response.Response.StatusCode
   693  			}
   694  			tracing.EndSpan(ctx, sc, err)
   695  		}()
   696  	}
   697  	if err := validation.Validate([]validation.Validation{
   698  		{TargetValue: resourceGroupName,
   699  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   700  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   701  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   702  		{TargetValue: clusterName,
   703  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   704  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   705  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z][-\w\._\(\)]+[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   706  		return result, validation.NewError("compute.OperationalizationClustersClient", "ListKeys", err.Error())
   707  	}
   708  
   709  	req, err := client.ListKeysPreparer(ctx, resourceGroupName, clusterName)
   710  	if err != nil {
   711  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListKeys", nil, "Failure preparing request")
   712  		return
   713  	}
   714  
   715  	resp, err := client.ListKeysSender(req)
   716  	if err != nil {
   717  		result.Response = autorest.Response{Response: resp}
   718  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListKeys", resp, "Failure sending request")
   719  		return
   720  	}
   721  
   722  	result, err = client.ListKeysResponder(resp)
   723  	if err != nil {
   724  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "ListKeys", resp, "Failure responding to request")
   725  		return
   726  	}
   727  
   728  	return
   729  }
   730  
   731  // ListKeysPreparer prepares the ListKeys request.
   732  func (client OperationalizationClustersClient) ListKeysPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) {
   733  	pathParameters := map[string]interface{}{
   734  		"clusterName":       autorest.Encode("path", clusterName),
   735  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   736  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   737  	}
   738  
   739  	const APIVersion = "2017-08-01-preview"
   740  	queryParameters := map[string]interface{}{
   741  		"api-version": APIVersion,
   742  	}
   743  
   744  	preparer := autorest.CreatePreparer(
   745  		autorest.AsPost(),
   746  		autorest.WithBaseURL(client.BaseURI),
   747  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningCompute/operationalizationClusters/{clusterName}/listKeys", pathParameters),
   748  		autorest.WithQueryParameters(queryParameters))
   749  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   750  }
   751  
   752  // ListKeysSender sends the ListKeys request. The method will close the
   753  // http.Response Body if it receives an error.
   754  func (client OperationalizationClustersClient) ListKeysSender(req *http.Request) (*http.Response, error) {
   755  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   756  }
   757  
   758  // ListKeysResponder handles the response to the ListKeys request. The method always
   759  // closes the http.Response Body.
   760  func (client OperationalizationClustersClient) ListKeysResponder(resp *http.Response) (result OperationalizationClusterCredentials, err error) {
   761  	err = autorest.Respond(
   762  		resp,
   763  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   764  		autorest.ByUnmarshallingJSON(&result),
   765  		autorest.ByClosing())
   766  	result.Response = autorest.Response{Response: resp}
   767  	return
   768  }
   769  
   770  // Update the PATCH operation can be used to update only the tags for a cluster. Use PUT operation to update other
   771  // properties.
   772  // Parameters:
   773  // resourceGroupName - name of the resource group in which the cluster is located.
   774  // clusterName - the name of the cluster.
   775  // parameters - the parameters supplied to patch the cluster.
   776  func (client OperationalizationClustersClient) Update(ctx context.Context, resourceGroupName string, clusterName string, parameters OperationalizationClusterUpdateParameters) (result OperationalizationCluster, err error) {
   777  	if tracing.IsEnabled() {
   778  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.Update")
   779  		defer func() {
   780  			sc := -1
   781  			if result.Response.Response != nil {
   782  				sc = result.Response.Response.StatusCode
   783  			}
   784  			tracing.EndSpan(ctx, sc, err)
   785  		}()
   786  	}
   787  	if err := validation.Validate([]validation.Validation{
   788  		{TargetValue: resourceGroupName,
   789  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   790  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   791  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   792  		{TargetValue: clusterName,
   793  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   794  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   795  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z][-\w\._\(\)]+[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   796  		return result, validation.NewError("compute.OperationalizationClustersClient", "Update", err.Error())
   797  	}
   798  
   799  	req, err := client.UpdatePreparer(ctx, resourceGroupName, clusterName, parameters)
   800  	if err != nil {
   801  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "Update", nil, "Failure preparing request")
   802  		return
   803  	}
   804  
   805  	resp, err := client.UpdateSender(req)
   806  	if err != nil {
   807  		result.Response = autorest.Response{Response: resp}
   808  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "Update", resp, "Failure sending request")
   809  		return
   810  	}
   811  
   812  	result, err = client.UpdateResponder(resp)
   813  	if err != nil {
   814  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "Update", resp, "Failure responding to request")
   815  		return
   816  	}
   817  
   818  	return
   819  }
   820  
   821  // UpdatePreparer prepares the Update request.
   822  func (client OperationalizationClustersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, clusterName string, parameters OperationalizationClusterUpdateParameters) (*http.Request, error) {
   823  	pathParameters := map[string]interface{}{
   824  		"clusterName":       autorest.Encode("path", clusterName),
   825  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   826  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   827  	}
   828  
   829  	const APIVersion = "2017-08-01-preview"
   830  	queryParameters := map[string]interface{}{
   831  		"api-version": APIVersion,
   832  	}
   833  
   834  	preparer := autorest.CreatePreparer(
   835  		autorest.AsContentType("application/json; charset=utf-8"),
   836  		autorest.AsPatch(),
   837  		autorest.WithBaseURL(client.BaseURI),
   838  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningCompute/operationalizationClusters/{clusterName}", pathParameters),
   839  		autorest.WithJSON(parameters),
   840  		autorest.WithQueryParameters(queryParameters))
   841  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   842  }
   843  
   844  // UpdateSender sends the Update request. The method will close the
   845  // http.Response Body if it receives an error.
   846  func (client OperationalizationClustersClient) UpdateSender(req *http.Request) (*http.Response, error) {
   847  	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
   848  }
   849  
   850  // UpdateResponder handles the response to the Update request. The method always
   851  // closes the http.Response Body.
   852  func (client OperationalizationClustersClient) UpdateResponder(resp *http.Response) (result OperationalizationCluster, err error) {
   853  	err = autorest.Respond(
   854  		resp,
   855  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   856  		autorest.ByUnmarshallingJSON(&result),
   857  		autorest.ByClosing())
   858  	result.Response = autorest.Response{Response: resp}
   859  	return
   860  }
   861  
   862  // UpdateSystemServices updates system services in a cluster.
   863  // Parameters:
   864  // resourceGroupName - name of the resource group in which the cluster is located.
   865  // clusterName - the name of the cluster.
   866  func (client OperationalizationClustersClient) UpdateSystemServices(ctx context.Context, resourceGroupName string, clusterName string) (result OperationalizationClustersUpdateSystemServicesFuture, err error) {
   867  	if tracing.IsEnabled() {
   868  		ctx = tracing.StartSpan(ctx, fqdn+"/OperationalizationClustersClient.UpdateSystemServices")
   869  		defer func() {
   870  			sc := -1
   871  			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
   872  				sc = result.FutureAPI.Response().StatusCode
   873  			}
   874  			tracing.EndSpan(ctx, sc, err)
   875  		}()
   876  	}
   877  	if err := validation.Validate([]validation.Validation{
   878  		{TargetValue: resourceGroupName,
   879  			Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   880  				{Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil},
   881  				{Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}},
   882  		{TargetValue: clusterName,
   883  			Constraints: []validation.Constraint{{Target: "clusterName", Name: validation.MaxLength, Rule: 90, Chain: nil},
   884  				{Target: "clusterName", Name: validation.MinLength, Rule: 1, Chain: nil},
   885  				{Target: "clusterName", Name: validation.Pattern, Rule: `^[a-zA-Z][-\w\._\(\)]+[a-zA-Z0-9]$`, Chain: nil}}}}); err != nil {
   886  		return result, validation.NewError("compute.OperationalizationClustersClient", "UpdateSystemServices", err.Error())
   887  	}
   888  
   889  	req, err := client.UpdateSystemServicesPreparer(ctx, resourceGroupName, clusterName)
   890  	if err != nil {
   891  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "UpdateSystemServices", nil, "Failure preparing request")
   892  		return
   893  	}
   894  
   895  	result, err = client.UpdateSystemServicesSender(req)
   896  	if err != nil {
   897  		err = autorest.NewErrorWithError(err, "compute.OperationalizationClustersClient", "UpdateSystemServices", result.Response(), "Failure sending request")
   898  		return
   899  	}
   900  
   901  	return
   902  }
   903  
   904  // UpdateSystemServicesPreparer prepares the UpdateSystemServices request.
   905  func (client OperationalizationClustersClient) UpdateSystemServicesPreparer(ctx context.Context, resourceGroupName string, clusterName string) (*http.Request, error) {
   906  	pathParameters := map[string]interface{}{
   907  		"clusterName":       autorest.Encode("path", clusterName),
   908  		"resourceGroupName": autorest.Encode("path", resourceGroupName),
   909  		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
   910  	}
   911  
   912  	const APIVersion = "2017-08-01-preview"
   913  	queryParameters := map[string]interface{}{
   914  		"api-version": APIVersion,
   915  	}
   916  
   917  	preparer := autorest.CreatePreparer(
   918  		autorest.AsPost(),
   919  		autorest.WithBaseURL(client.BaseURI),
   920  		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningCompute/operationalizationClusters/{clusterName}/updateSystemServices", pathParameters),
   921  		autorest.WithQueryParameters(queryParameters))
   922  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   923  }
   924  
   925  // UpdateSystemServicesSender sends the UpdateSystemServices request. The method will close the
   926  // http.Response Body if it receives an error.
   927  func (client OperationalizationClustersClient) UpdateSystemServicesSender(req *http.Request) (future OperationalizationClustersUpdateSystemServicesFuture, err error) {
   928  	var resp *http.Response
   929  	future.FutureAPI = &azure.Future{}
   930  	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
   931  	if err != nil {
   932  		return
   933  	}
   934  	var azf azure.Future
   935  	azf, err = azure.NewFutureFromResponse(resp)
   936  	future.FutureAPI = &azf
   937  	future.Result = future.result
   938  	return
   939  }
   940  
   941  // UpdateSystemServicesResponder handles the response to the UpdateSystemServices request. The method always
   942  // closes the http.Response Body.
   943  func (client OperationalizationClustersClient) UpdateSystemServicesResponder(resp *http.Response) (result UpdateSystemServicesResponse, err error) {
   944  	err = autorest.Respond(
   945  		resp,
   946  		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted),
   947  		autorest.ByUnmarshallingJSON(&result),
   948  		autorest.ByClosing())
   949  	result.Response = autorest.Response{Response: resp}
   950  	return
   951  }
   952
View as plain text