internal virtual CreateClusterResponse CreateCluster(CreateClusterRequest request)
{
var marshaller = CreateClusterRequestMarshaller.Instance;
var unmarshaller = CreateClusterResponseUnmarshaller.Instance;
return(Invoke <CreateClusterRequest, CreateClusterResponse>(request, marshaller, unmarshaller));
}
/// <summary>Snippet for CreateCluster</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void CreateClusterRequestObject()
{
// Create client
BigtableInstanceAdminClient bigtableInstanceAdminClient = BigtableInstanceAdminClient.Create();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
ParentAsInstanceName = InstanceName.FromProjectInstance("[PROJECT]", "[INSTANCE]"),
ClusterId = "",
Cluster = new Cluster(),
};
// Make the request
Operation <Cluster, CreateClusterMetadata> response = bigtableInstanceAdminClient.CreateCluster(request);
// Poll until the returned long-running operation is complete
Operation <Cluster, CreateClusterMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Cluster result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Cluster, CreateClusterMetadata> retrievedResponse = bigtableInstanceAdminClient.PollOnceCreateCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Cluster retrievedResult = retrievedResponse.Result;
}
}
/// <summary>
/// Creates a new AWS CloudHSM cluster.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateCluster service method.</param>
///
/// <returns>The response from the CreateCluster service method, as returned by CloudHSMV2.</returns>
/// <exception cref="Amazon.CloudHSMV2.Model.CloudHsmAccessDeniedException">
/// The request was rejected because the requester does not have permission to perform
/// the requested operation.
/// </exception>
/// <exception cref="Amazon.CloudHSMV2.Model.CloudHsmInternalFailureException">
/// The request was rejected because of an AWS CloudHSM internal failure. The request
/// can be retried.
/// </exception>
/// <exception cref="Amazon.CloudHSMV2.Model.CloudHsmInvalidRequestException">
/// The request was rejected because it is not a valid request.
/// </exception>
/// <exception cref="Amazon.CloudHSMV2.Model.CloudHsmResourceNotFoundException">
/// The request was rejected because it refers to a resource that cannot be found.
/// </exception>
/// <exception cref="Amazon.CloudHSMV2.Model.CloudHsmServiceException">
/// The request was rejected because an error occurred.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/cloudhsmv2-2017-04-28/CreateCluster">REST API Reference for CreateCluster Operation</seealso>
public CreateClusterResponse CreateCluster(CreateClusterRequest request)
{
var marshaller = new CreateClusterRequestMarshaller();
var unmarshaller = CreateClusterResponseUnmarshaller.Instance;
return(Invoke <CreateClusterRequest, CreateClusterResponse>(request, marshaller, unmarshaller));
}
/// <summary>
/// Create a new cluster.
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/containerengine/CreateCluster.cs.html">here</a> to see an example of how to use CreateCluster API.</example>
public async Task <CreateClusterResponse> CreateCluster(CreateClusterRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called createCluster");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/clusters".Trim('/')));
HttpMethod method = new HttpMethod("POST");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <CreateClusterResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"CreateCluster failed with error: {e.Message}");
throw;
}
}
private CreateClusterRequest CreateClusterRequest(RedshiftDeveloperOptions devOptions)
{
var request = new CreateClusterRequest()
{
AllowVersionUpgrade = devOptions.AllowVersionUpgrade,
AutomatedSnapshotRetentionPeriod = devOptions.AutomatedSnapshotRetentionPeriod,
AvailabilityZone = devOptions.AvailabilityZone,
ClusterIdentifier = devOptions.ClusterIdentifier,
ClusterParameterGroupName = devOptions.ClusterParameterGroupName,
ClusterSecurityGroups = devOptions.ClusterSecurityGroups,
ClusterSubnetGroupName = devOptions.ClusterSubnetGroupName,
ClusterType = devOptions.ClusterType,
ClusterVersion = devOptions.ClusterVersion,
DBName = devOptions.DBName,
ElasticIp = devOptions.ElasticIp,
Encrypted = devOptions.Encrypted,
HsmClientCertificateIdentifier = devOptions.HSMClientCertificateIdentifier,
HsmConfigurationIdentifier = devOptions.HSMClientConfigurationIdentifier,
MasterUsername = devOptions.MasterUserName,
MasterUserPassword = devOptions.MasterPassword,
NodeType = devOptions.NodeType,
NumberOfNodes = devOptions.NumberOfNodes,
Port = devOptions.Port,
PreferredMaintenanceWindow = devOptions.PreferredMaintenanceWindow,
PubliclyAccessible = devOptions.PubliclyAccessible,
VpcSecurityGroupIds = devOptions.VpcSecurityGroupIds
};
return(request);
}
public void CreateClusterTest()
{
var createClusterRequest = new CreateClusterRequest("ep_net_sdk_tests");
var mockNetwork = new Mock <INetwork>(MockBehavior.Strict);
mockNetwork
.Setup(n => n.Invoke(createClusterRequest))
.Returns(new MockHttpWebResponse("SpectraLogic.SpectraRioBrokerClient.Test.TestFiles.CreateClusterResponse",
HttpStatusCode.Created, null));
var mockBuilder = new Mock <ISpectraRioBrokerClientBuilder>(MockBehavior.Strict);
mockBuilder
.Setup(b => b.Build())
.Returns(new SpectraRioBrokerClient(mockNetwork.Object));
var builder = mockBuilder.Object;
var client = builder.Build();
var cluster = client.CreateCluster(createClusterRequest);
Assert.AreEqual("ep_net_sdk_tests", cluster.Name);
mockBuilder.VerifyAll();
mockNetwork.VerifyAll();
}
/// <summary>Snippet for CreateCluster</summary>
public void CreateClusterRequestObject()
{
// Snippet: CreateCluster(CreateClusterRequest, CallSettings)
// Create client
ClusterControllerClient clusterControllerClient = ClusterControllerClient.Create();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
ProjectId = "",
Cluster = new Cluster(),
Region = "",
RequestId = "",
};
// Make the request
Operation <Cluster, ClusterOperationMetadata> response = clusterControllerClient.CreateCluster(request);
// Poll until the returned long-running operation is complete
Operation <Cluster, ClusterOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Cluster result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Cluster, ClusterOperationMetadata> retrievedResponse = clusterControllerClient.PollOnceCreateCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Cluster retrievedResult = retrievedResponse.Result;
}
// End snippet
}
public static object CreateCluster(string instanceId)
{
// [START bigtable_create_bigtableInstanceAdminClient]
BigtableInstanceAdminClient bigtableInstanceAdminClient = BigtableInstanceAdminClient.Create();
// [END bigtable_create_bigtableInstanceAdminClient]
Console.WriteLine("Print current instance information");
GetInstance(instanceId);
// Please refer to the link below for the full list of availabel locations:
// https://cloud.google.com/bigtable/docs/locations
string zone2 = "us-east1-d";
Console.WriteLine("Creating cluster");
// [START bigtable_create_cluster]
// Create an additional cluster with cluster id "ssd-cluster2" with 3 nodes and location us-east1-d.
// Additional cluster can only be created in PRODUCTION type instance.
// Additional cluster must have same storage type as existing cluster.
// Please read about routing_policy for more information on mutli cluster instances.
// https://cloud.google.com/bigtable/docs/reference/admin/rpc/google.bigtable.admin.v2#google.bigtable.admin.v2.AppProfile.MultiClusterRoutingUseAny
// Cluster to be created within the instance.
Cluster myCluster2 = new Cluster
{
DefaultStorageType = StorageType.Ssd,
LocationAsLocationName = new LocationName(projectId, zone2),
ServeNodes = 3
};
// Initialize request argument(s).
CreateClusterRequest request = new CreateClusterRequest
{
ParentAsInstanceName = new InstanceName(projectId, instanceId),
ClusterId = "ssd-cluster2",
Cluster = myCluster2
};
try
{
// Make the request
Console.WriteLine("Waiting for operation to complete...");
Operation <Cluster, CreateClusterMetadata> response = bigtableInstanceAdminClient.CreateCluster(request);
// Poll until the returned long-running operation is complete
Operation <Cluster, CreateClusterMetadata> completedResponse = response.PollUntilCompleted();
// [END bigtable_create_cluster]
Console.WriteLine($"Cluster {request.ClusterId} was created successfully in instance {instanceId}");
Console.WriteLine("Print intance information after cluster is created");
GetInstance(instanceId);
// [START bigtable_create_cluster]
}
catch (Exception ex)
{
Console.WriteLine($"Exception creating additional cluster {request.ClusterId} in instance {instanceId}");
Console.WriteLine(ex.Message);
}
// [END bigtable_create_cluster]
return(0);
}
public async Task CreateCluster()
{
var request = new CreateClusterRequest
{
ClusterName = _context.Settings.Cluster.Name
};
await _client.CreateClusterAsync(request);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateCluster operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateCluster operation on AmazonEKSClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCluster
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/eks-2017-11-01/CreateCluster">REST API Reference for CreateCluster Operation</seealso>
public virtual IAsyncResult BeginCreateCluster(CreateClusterRequest request, AsyncCallback callback, object state)
{
var marshaller = CreateClusterRequestMarshaller.Instance;
var unmarshaller = CreateClusterResponseUnmarshaller.Instance;
return(BeginInvoke <CreateClusterRequest>(request, marshaller, unmarshaller,
callback, state));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateCluster operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateCluster operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/dax-2017-04-19/CreateCluster">REST API Reference for CreateCluster Operation</seealso>
public virtual Task <CreateClusterResponse> CreateClusterAsync(CreateClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = CreateClusterRequestMarshaller.Instance;
var unmarshaller = CreateClusterResponseUnmarshaller.Instance;
return(InvokeAsync <CreateClusterRequest, CreateClusterResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateCluster operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateCluster operation on AmazonEKSClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCluster
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/eks-2017-11-01/CreateCluster">REST API Reference for CreateCluster Operation</seealso>
public virtual IAsyncResult BeginCreateCluster(CreateClusterRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance;
return(BeginInvoke(request, options, callback, state));
}
public void CreateCluster()
{
var request = new CreateClusterRequest
{
ClusterName = _context.Settings.Cluster.Name
};
_client.CreateCluster(request);
}
/// <summary>
/// 创建集群
/// </summary>
public async Task <CreateClusterResponse> CreateClusterAsync(CreateClusterRequest createClusterRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
string urlPath = HttpUtils.AddUrlPath("/api/v3/projects/{project_id}/clusters", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json", createClusterRequest);
HttpResponseMessage response = await DoHttpRequestAsync("POST", request);
return(JsonUtils.DeSerialize <CreateClusterResponse>(response));
}
internal virtual CreateClusterResponse CreateCluster(CreateClusterRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance;
return(Invoke <CreateClusterResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateCluster operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateCluster operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/snowball-2016-06-30/CreateCluster">REST API Reference for CreateCluster Operation</seealso>
public virtual Task <CreateClusterResponse> CreateClusterAsync(CreateClusterRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateClusterRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateClusterResponseUnmarshaller.Instance;
return(InvokeAsync <CreateClusterResponse>(request, options, cancellationToken));
}
public async Task <CreateClusterResponse> CreateClusterAsync(string clusterName)
{
var request = new CreateClusterRequest
{
ClusterName = clusterName
};
var response = await _containerServiceClient.CreateClusterAsync(request);
return(response);
}
private void TestClusterEndToEnd(
CreateClusterRequest cluster,
Func <Collection <ListClusterContainerResult> > getClusters,
Func <string, ListClusterContainerResult> getCluster,
Func <CreateClusterRequest, ListClusterContainerResult> createCluster,
Action <string> deleteCluster)
{
// Identifies if it needs to validate Metastores
var restClientType = ServiceLocator.Instance.Locate <IHDInsightManagementRestClientFactory>().GetType();
var validateMetastores = cluster.OozieMetastore != null && cluster.HiveMetastore != null &&
restClientType != typeof(HDInsightManagementRestSimulatorClientFactory);
//// Deletes previous metastore schema data
//if (validateMetastores)
//{
// DeleteAllTables(cluster.OozieMetastore);
// DeleteAllTables(cluster.HiveMetastore);
//}
//// Verifies it doesn't exist
//var listResult = getClusters();
//int matchingContainers = listResult.Count(container => container.DnsName.Equals(cluster.DnsName));
//Assert.AreEqual(0, matchingContainers);
cluster.DnsName = "clitest-pudev2-050100-106c62b3f1c644f4a5f747d428985547";
cluster.ClusterUserPassword = "******";
var result = getCluster(cluster.DnsName);
//// Creates the cluster
//var result = createCluster(cluster);
//Assert.IsNotNull(result);
//Assert.IsNotNull(getCluster(cluster.DnsName));
// Validates the cluster
var tableName = "newtable" + Guid.NewGuid().ToString("N");
CreateTable(tableName, result.ConnectionUrl, cluster.ClusterUserName, cluster.ClusterUserPassword, cluster.DefaultAsvAccountName, cluster.DefaultAsvAccountKey);
RunJob(tableName, result.ConnectionUrl, cluster.ClusterUserName, cluster.ClusterUserPassword, cluster.DefaultAsvAccountName, cluster.DefaultAsvAccountKey);
if (validateMetastores)
{
Assert.AreNotEqual(0, GetTables(cluster.HiveMetastore).Count);
Assert.AreNotEqual(0, GetTables(cluster.OozieMetastore).Count);
ValidateTable(tableName, cluster.HiveMetastore);
}
// Deletes the cluster
deleteCluster(cluster.DnsName);
// Verifies it doesn't exist
Assert.IsNull(getCluster(cluster.DnsName));
}
public async Task <BigCluster> CreateClusterAsync(string name)
{
var request = new CreateClusterRequest
{
Name = Config.ToZoneId(),
ClusterId = name
};
var response = await _client.CreateClusterAsync(request);
await Task.Yield();
return(new BigCluster(this, response));
}
/// <summary>
/// 本接口用于创建TcaplusDB集群
/// </summary>
/// <param name="req"><see cref="CreateClusterRequest"/></param>
/// <returns><see cref="CreateClusterResponse"/></returns>
public CreateClusterResponse CreateClusterSync(CreateClusterRequest req)
{
JsonResponseModel <CreateClusterResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "CreateCluster");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateClusterResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public static void CreateCluster()
{
ClusterName = ConfigurationManager.AppSettings["ClusterName"];
var getClusterRequest = new GetClusterRequest();
try
{
SpectraRioBrokerClient.GetCluster(getClusterRequest);
}
catch (NodeIsNotAClusterMemberException)
{
var createClusterRequest = new CreateClusterRequest(ClusterName);
SpectraRioBrokerClient.CreateCluster(createClusterRequest);
/* Adding 1 sec sleep after the cluster creation to avid getting a <400, There is not an active key>
* when trying to create a spectra device.
*/
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
/**
* Creates a Cluster and waits for it to become active
*
* @param containerEngineClient the containerEngineclient used to create the cluster
* @param vcnId the ID of the VCN which will own the subnets
* @param subnetIds list of subnet ids
* @param kubernetesVersion kubernetesVersion
* @param compartmentId
*
* @return the created cluster
*/
private static async Task <Cluster> CreateCluster(
ContainerEngineClient containerEngineClient, string vcnId, List <string> subnetIds,
string kubernetesVersion, string compartmentId)
{
logger.Info("Creating Cluster.......");
CreateClusterDetails createClusterDetails = new CreateClusterDetails
{
Name = ClusterDisplayName,
CompartmentId = compartmentId,
VcnId = vcnId,
KubernetesVersion = kubernetesVersion,
Options = new ClusterCreateOptions
{
ServiceLbSubnetIds = subnetIds
}
};
CreateClusterRequest createClusterRequest = new CreateClusterRequest
{
CreateClusterDetails = createClusterDetails
};
CreateClusterResponse clusterResponse = await containerEngineClient.CreateCluster(createClusterRequest);
string workRequestId = clusterResponse.OpcWorkRequestId;
logger.Info($"cluster work request ID is {workRequestId}");
GetWorkRequestResponse workRequestResponse = WaitForWorkRequestFinished(containerEngineClient, workRequestId);
var clusterId = GetClusterId(workRequestResponse);
logger.Info($"cluster ID is {clusterId}");
GetClusterRequest getClusterRequest = new GetClusterRequest
{
ClusterId = clusterId
};
GetClusterResponse getClusterResponse = await containerEngineClient.GetCluster(getClusterRequest);
return(getClusterResponse.Cluster);
}
/// <summary>Snippet for CreateClusterAsync</summary>
public async Task CreateClusterAsync_RequestObject()
{
// Snippet: CreateClusterAsync(CreateClusterRequest,CallSettings)
// Create client
BigtableInstanceAdminClient bigtableInstanceAdminClient = await BigtableInstanceAdminClient.CreateAsync();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
ParentAsInstanceName = new InstanceName("[PROJECT]", "[INSTANCE]"),
ClusterId = "",
Cluster = new Cluster(),
};
// Make the request
Operation <Cluster, CreateClusterMetadata> response =
await bigtableInstanceAdminClient.CreateClusterAsync(request);
// Poll until the returned long-running operation is complete
Operation <Cluster, CreateClusterMetadata> completedResponse =
await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Cluster, CreateClusterMetadata> retrievedResponse =
await bigtableInstanceAdminClient.PollOnceCreateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Cluster retrievedResult = retrievedResponse.Result;
}
// End snippet
}
public CreateClusterResponse SaveCluster(CreateClusterRequest clusterRequest)
{
var createClusterResponse = new CreateClusterResponse();
var cluster = _messageMapper.MapToCluster(clusterRequest.Cluster);
try
{
_clusterRepository.SaveCluster(cluster);
var clusterDto = _messageMapper.MapToClusterDto(cluster);
createClusterResponse.Cluster = clusterDto;
createClusterResponse.Messages.Add("Successfully saved the cluster");
createClusterResponse.StatusCode = HttpStatusCode.Created;
}
catch (Exception e)
{
var error = e.ToString();
createClusterResponse.Messages.Add(error);
createClusterResponse.StatusCode = HttpStatusCode.InternalServerError;
}
return(createClusterResponse);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateClusterRequest request;
try
{
request = new CreateClusterRequest
{
CreateClusterDetails = CreateClusterDetails,
OpcRetryToken = OpcRetryToken,
OpcRequestId = OpcRequestId
};
response = client.CreateCluster(request).GetAwaiter().GetResult();
WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId));
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
/// <inheritdoc/>
public ICluster CreateCluster(CreateClusterRequest request)
{
return(ExceptionDecorator.Run(() => new CreateClusterResponseParser().Parse(_network.Invoke(request))));
}
public ActionResult <CreateClusterResponse> PostCluster(CreateClusterRequest createClusterRequest) //Model binding
{
var createClusterResponse = _clusterService.SaveCluster(createClusterRequest);
return(createClusterResponse);
}
private void TestClusterEndToEnd(
CreateClusterRequest cluster,
Func<Collection<ListClusterContainerResult>> getClusters,
Func<string, ListClusterContainerResult> getCluster,
Func<CreateClusterRequest, ListClusterContainerResult> createCluster,
Action<string> deleteCluster)
{
// Identifies if it needs to validate Metastores
var restClientType = ServiceLocator.Instance.Locate<IHDInsightManagementRestClientFactory>().GetType();
var validateMetastores = cluster.OozieMetastore != null && cluster.HiveMetastore != null &&
restClientType != typeof(HDInsightManagementRestSimulatorClientFactory);
//// Deletes previous metastore schema data
//if (validateMetastores)
//{
// DeleteAllTables(cluster.OozieMetastore);
// DeleteAllTables(cluster.HiveMetastore);
//}
//// Verifies it doesn't exist
//var listResult = getClusters();
//int matchingContainers = listResult.Count(container => container.DnsName.Equals(cluster.DnsName));
//Assert.AreEqual(0, matchingContainers);
cluster.DnsName = "clitest-pudev2-050100-106c62b3f1c644f4a5f747d428985547";
cluster.ClusterUserPassword = "******";
var result = getCluster(cluster.DnsName);
//// Creates the cluster
//var result = createCluster(cluster);
//Assert.IsNotNull(result);
//Assert.IsNotNull(getCluster(cluster.DnsName));
// Validates the cluster
var tableName = "newtable" + Guid.NewGuid().ToString("N");
CreateTable(tableName, result.ConnectionUrl, cluster.ClusterUserName, cluster.ClusterUserPassword, cluster.DefaultAsvAccountName, cluster.DefaultAsvAccountKey);
RunJob(tableName, result.ConnectionUrl, cluster.ClusterUserName, cluster.ClusterUserPassword, cluster.DefaultAsvAccountName, cluster.DefaultAsvAccountKey);
if (validateMetastores)
{
Assert.AreNotEqual(0, GetTables(cluster.HiveMetastore).Count);
Assert.AreNotEqual(0, GetTables(cluster.OozieMetastore).Count);
ValidateTable(tableName, cluster.HiveMetastore);
}
// Deletes the cluster
deleteCluster(cluster.DnsName);
// Verifies it doesn't exist
Assert.IsNull(getCluster(cluster.DnsName));
}
/// <summary>
/// - 创建集群
/// - 证书
/// - 关于kubernetes的证书，默认生成，不需要用户传入。
/// - nodegroup
/// - cluster必须与nodeGroup进行绑定
/// - cluster支持多nodegroup
/// - 状态
/// - pending,reconciling,deleting状态不可以操作更新接口
/// - running，running_with_error状态可以操作nodegroup所有接口
/// - error状态只可以查询，删除
/// - delete状态的cluster在十五分钟内可以查询，十五分钟后无法查询到
/// - 状态限制
/// - pending,reconciling,deleting状态不可以操作更新接口
/// - running状态可以操作cluster所有接口
/// - error状态只可以查询，删除
/// - delete状态的cluster在十五分钟内可以查询，十五分钟后无法查询到
///
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public async Task <CreateClusterResponse> CreateCluster(CreateClusterRequest request)
{
return(await new CreateClusterExecutor().Client(this).Execute <CreateClusterResponse, CreateClusterResult, CreateClusterRequest>(request).ConfigureAwait(false));
}
/// <summary>
/// - 创建集群
/// - 证书
/// - 关于kubernetes的证书，默认生成，不需要用户传入。
/// - nodegroup
/// - cluster必须与nodeGroup进行绑定
/// - cluster支持多nodegroup
/// - 状态
/// - pending,reconciling,deleting状态不可以操作更新接口
/// - running，running_with_error状态可以操作nodegroup所有接口
/// - error状态只可以查询，删除
/// - delete状态的cluster在十五分钟内可以查询，十五分钟后无法查询到
/// - 状态限制
/// - pending,reconciling,deleting状态不可以操作更新接口
/// - running状态可以操作cluster所有接口
/// - error状态只可以查询，删除
/// - delete状态的cluster在十五分钟内可以查询，十五分钟后无法查询到
///
/// </summary>
/// <param name="request">请求参数信息</param>
/// <returns>请求结果信息</returns>
public CreateClusterResponse CreateCluster(CreateClusterRequest request)
{
return(new CreateClusterExecutor().Client(this).Execute <CreateClusterResponse, CreateClusterResult, CreateClusterRequest>(request));
}
