public async Task GetClusterAsync()
{
Mock <ClusterController.ClusterControllerClient> mockGrpcClient = new Mock <ClusterController.ClusterControllerClient>(MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient())
.Returns(new Mock <Operations.OperationsClient>().Object);
GetClusterRequest expectedRequest = new GetClusterRequest
{
ProjectId = "projectId-1969970175",
Region = "region-934795532",
ClusterName = "clusterName-1018081872",
};
Cluster expectedResponse = new Cluster
{
ProjectId = "projectId2939242356",
ClusterName = "clusterName2875867491",
ClusterUuid = "clusterUuid-1017854240",
};
mockGrpcClient.Setup(x => x.GetClusterAsync(expectedRequest, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Cluster>(Task.FromResult(expectedResponse), null, null, null, null));
ClusterControllerClient client = new ClusterControllerClientImpl(mockGrpcClient.Object, null);
string projectId = "projectId-1969970175";
string region = "region-934795532";
string clusterName = "clusterName-1018081872";
Cluster response = await client.GetClusterAsync(projectId, region, clusterName);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/**
* Update a cluster and waits for it to become active
*
* @param containerEngineClient the service client to use to delete the cluster
* @param clusterId the cluster ID
* @param newClusterName The new cluster name
*
*/
private static async Task UpdateCluster(
ContainerEngineClient containerEngineClient, string clusterId, string newClusterName)
{
UpdateClusterDetails updateClusterDetails = new UpdateClusterDetails
{
Name = newClusterName
};
UpdateClusterRequest updateClusterRequest = new UpdateClusterRequest
{
ClusterId = clusterId,
UpdateClusterDetails = updateClusterDetails
};
UpdateClusterResponse updateClusterResponse = await containerEngineClient.UpdateCluster(updateClusterRequest);
string workRequestId = updateClusterResponse.OpcWorkRequestId;
GetWorkRequestResponse workRequestResponse = WaitForWorkRequestFinished(containerEngineClient, workRequestId);
GetClusterRequest getClusterRequest = new GetClusterRequest
{
ClusterId = clusterId
};
GetClusterResponse getClusterResponse = await containerEngineClient.GetCluster(getClusterRequest);
Cluster cluster = getClusterResponse.Cluster;
logger.Info($"Cluster name is changed to {cluster.Name}");
}
/// <summary>
/// Get the details of a 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/GetCluster.cs.html">here</a> to see an example of how to use GetCluster API.</example>
public async Task <GetClusterResponse> GetCluster(GetClusterRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called getCluster");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/clusters/{clusterId}".Trim('/')));
HttpMethod method = new HttpMethod("GET");
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 <GetClusterResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"GetCluster failed with error: {e.Message}");
throw;
}
}
public void GetClusterTest()
{
var getClusterRequest = new GetClusterRequest();
var mockNetwork = new Mock <INetwork>(MockBehavior.Strict);
mockNetwork
.Setup(n => n.Invoke(getClusterRequest))
.Returns(new MockHttpWebResponse("SpectraLogic.SpectraRioBrokerClient.Test.TestFiles.GetClusterResponse",
HttpStatusCode.OK, 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.GetCluster(getClusterRequest);
Assert.AreEqual("ep_net_sdk_tests", cluster.Name);
mockBuilder.VerifyAll();
mockNetwork.VerifyAll();
}
public void GetCluster2()
{
Mock <ClusterController.ClusterControllerClient> mockGrpcClient = new Mock <ClusterController.ClusterControllerClient>(MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient())
.Returns(new Mock <Operations.OperationsClient>().Object);
GetClusterRequest request = new GetClusterRequest
{
ProjectId = "projectId-1969970175",
Region = "region-934795532",
ClusterName = "clusterName-1018081872",
};
Cluster expectedResponse = new Cluster
{
ProjectId = "projectId2939242356",
ClusterName = "clusterName2875867491",
ClusterUuid = "clusterUuid-1017854240",
};
mockGrpcClient.Setup(x => x.GetCluster(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
ClusterControllerClient client = new ClusterControllerClientImpl(mockGrpcClient.Object, null);
Cluster response = client.GetCluster(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public ActionResult <GetClusterResponse> GetCluster(long id)
{
var getClusterRequest = new GetClusterRequest
{
Id = id
};
var getClusterResponse = _clusterService.GetCluster(getClusterRequest);
return(getClusterResponse);
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetClusterRequest, GetClusterResponse> ForCluster(GetClusterRequest request, WaiterConfiguration config, params ClusterLifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetClusterRequest, GetClusterResponse>(
request,
request => client.GetCluster(request),
response => targetStates.Contains(response.Cluster.LifecycleState.Value),
targetStates.Contains(ClusterLifecycleState.Deleted)
);
return(new Waiter <GetClusterRequest, GetClusterResponse>(config, agent));
}
public async Task <BigCluster> GetClusterAsync(string name)
{
var request = new GetClusterRequest {
Name = name.ToClusterId(Config.ToZoneId())
};
var response = await _client.GetClusterAsync(request);
await Task.Yield();
return(new BigCluster(this, response));
}
/// <summary>Snippet for GetCluster</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void GetClusterRequestObject()
{
// Create client
BigtableInstanceAdminClient bigtableInstanceAdminClient = BigtableInstanceAdminClient.Create();
// Initialize request argument(s)
GetClusterRequest request = new GetClusterRequest
{
ClusterName = ClusterName.FromProjectInstanceCluster("[PROJECT]", "[INSTANCE]", "[CLUSTER]"),
};
// Make the request
Cluster response = bigtableInstanceAdminClient.GetCluster(request);
}
/// <summary>Snippet for GetCluster</summary>
public void GetCluster_RequestObject()
{
// Snippet: GetCluster(GetClusterRequest,CallSettings)
// Create client
BigtableInstanceAdminClient bigtableInstanceAdminClient = BigtableInstanceAdminClient.Create();
// Initialize request argument(s)
GetClusterRequest request = new GetClusterRequest
{
ClusterName = new ClusterName("[PROJECT]", "[INSTANCE]", "[CLUSTER]"),
};
// Make the request
Cluster response = bigtableInstanceAdminClient.GetCluster(request);
// End snippet
}
/// <summary>Snippet for GetCluster</summary>
public void GetCluster_RequestObject()
{
// Snippet: GetCluster(GetClusterRequest,CallSettings)
// Create client
ClusterControllerClient clusterControllerClient = ClusterControllerClient.Create();
// Initialize request argument(s)
GetClusterRequest request = new GetClusterRequest
{
ProjectId = "",
Region = "",
ClusterName = "",
};
// Make the request
Cluster response = clusterControllerClient.GetCluster(request);
// End snippet
}
public GetClusterResponse GetCluster(GetClusterRequest getClusterRequest)
{
GetClusterResponse getClusterResponse = null;
if (getClusterRequest.Id > 0)
{
var cluster = _clusterRepository.FindClusterById(getClusterRequest.Id);
var clusterDto = _messageMapper.MapToClusterDto(cluster);
getClusterResponse = new GetClusterResponse
{
Cluster = clusterDto
};
}
return(getClusterResponse);
}
/// <summary>Snippet for GetClusterAsync</summary>
public async Task GetClusterAsync_RequestObject()
{
// Snippet: GetClusterAsync(GetClusterRequest,CallSettings)
// Create client
ClusterControllerClient clusterControllerClient = await ClusterControllerClient.CreateAsync();
// Initialize request argument(s)
GetClusterRequest request = new GetClusterRequest
{
ProjectId = "",
Region = "",
ClusterName = "",
};
// Make the request
Cluster response = await clusterControllerClient.GetClusterAsync(request);
// End snippet
}
public async stt::Task GetClusterRequestObjectAsync()
{
moq::Mock <ClusterController.ClusterControllerClient> mockGrpcClient = new moq::Mock <ClusterController.ClusterControllerClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetClusterRequest request = new GetClusterRequest
{
ProjectId = "project_id43ad98b0",
ClusterName = "cluster_name88432a5e",
Region = "regionedb20d96",
};
Cluster expectedResponse = new Cluster
{
ProjectId = "project_id43ad98b0",
ClusterName = "cluster_name88432a5e",
Config = new ClusterConfig(),
Status = new ClusterStatus(),
ClusterUuid = "cluster_uuid256bc378",
StatusHistory =
{
new ClusterStatus(),
},
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
Metrics = new ClusterMetrics(),
};
mockGrpcClient.Setup(x => x.GetClusterAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Cluster>(stt::Task.FromResult(expectedResponse), null, null, null, null));
ClusterControllerClient client = new ClusterControllerClientImpl(mockGrpcClient.Object, null);
Cluster responseCallSettings = await client.GetClusterAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Cluster responseCancellationToken = await client.GetClusterAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
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));
}
}
private void HandleOutput(GetClusterRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForCluster(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetCluster(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.Cluster);
}
/**
* 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);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetClusterRequest request;
try
{
request = new GetClusterRequest
{
ClusterId = ClusterId,
OpcRequestId = OpcRequestId
};
HandleOutput(request);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public void GetClusterRequestObject()
{
moq::Mock <ClusterController.ClusterControllerClient> mockGrpcClient = new moq::Mock <ClusterController.ClusterControllerClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetClusterRequest request = new GetClusterRequest
{
ProjectId = "project_id43ad98b0",
ClusterName = "cluster_name88432a5e",
Region = "regionedb20d96",
};
Cluster expectedResponse = new Cluster
{
ProjectId = "project_id43ad98b0",
ClusterName = "cluster_name88432a5e",
Config = new ClusterConfig(),
Status = new ClusterStatus(),
ClusterUuid = "cluster_uuid256bc378",
StatusHistory =
{
new ClusterStatus(),
},
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
Metrics = new ClusterMetrics(),
};
mockGrpcClient.Setup(x => x.GetCluster(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
ClusterControllerClient client = new ClusterControllerClientImpl(mockGrpcClient.Object, null);
Cluster response = client.GetCluster(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Creates a waiter using default wait configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetClusterRequest, GetClusterResponse> ForCluster(GetClusterRequest request, params ClusterLifecycleState[] targetStates)
{
return(this.ForCluster(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates));
}
/// <inheritdoc/>
public ICluster GetCluster(GetClusterRequest request)
{
return(ExceptionDecorator.Run(() => new GetClusterResponseParser().Parse(_network.Invoke(request))));
}
