public async stt::Task GetDeploymentRequestObjectAsync()
{
moq::Mock <Deployments.DeploymentsClient> mockGrpcClient = new moq::Mock <Deployments.DeploymentsClient>(moq::MockBehavior.Strict);
GetDeploymentRequest request = new GetDeploymentRequest
{
DeploymentName = DeploymentName.FromProjectLocationAgentEnvironmentDeployment("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]", "[DEPLOYMENT]"),
};
Deployment expectedResponse = new Deployment
{
DeploymentName = DeploymentName.FromProjectLocationAgentEnvironmentDeployment("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]", "[DEPLOYMENT]"),
FlowVersionAsVersionName = VersionName.FromProjectLocationAgentFlowVersion("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]"),
State = Deployment.Types.State.Succeeded,
Result = new Deployment.Types.Result(),
StartTime = new wkt::Timestamp(),
EndTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.GetDeploymentAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Deployment>(stt::Task.FromResult(expectedResponse), null, null, null, null));
DeploymentsClient client = new DeploymentsClientImpl(mockGrpcClient.Object, null);
Deployment responseCallSettings = await client.GetDeploymentAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Deployment responseCancellationToken = await client.GetDeploymentAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Gets the deployment info
/// </summary>
/// <param name="deploymentID">A deployment ID associated with the applicable IAM user or AWS account.</param>
/// <param name="settings">The <see cref="DeploySettings"/> used during the request to AWS.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
public async Task <DeploymentInfo> GetDeploymentInfo(string deploymentID, DeploySettings settings, CancellationToken cancellationToken = default(CancellationToken))
{
if (String.IsNullOrEmpty(deploymentID))
{
throw new ArgumentNullException("deploymentID");
}
// Create Request
AmazonCodeDeployClient client = this.CreateClient(settings);
GetDeploymentRequest request = new GetDeploymentRequest();
request.DeploymentId = deploymentID;
// Check Response
GetDeploymentResponse response = await client.GetDeploymentAsync(request, cancellationToken);
if (response.HttpStatusCode == HttpStatusCode.OK)
{
_Log.Verbose("Successfully found deployment info '{0}'", deploymentID);
return(response.DeploymentInfo);
}
else
{
_Log.Error("Failed to get deployment info '{0}'", deploymentID);
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// The RPC response.
/// </returns>
public override GetDeploymentResponse GetDeployment(
GetDeploymentRequest request,
gaxgrpc::CallSettings callSettings = null)
{
Modify_GetDeploymentRequest(ref request, ref callSettings);
return(_callGetDeployment.Sync(request, callSettings));
}
private async Task <Deployment> GetDeployment(ObjectId id)
{
var request = new GetDeploymentRequest(id);
var response = await _mediator.Send(request).ConfigureAwait(false);
return(response.Deployment);
}
/// <summary>
///
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override stt::Task <GetDeploymentResponse> GetDeploymentAsync(
GetDeploymentRequest request,
gaxgrpc::CallSettings callSettings = null)
{
Modify_GetDeploymentRequest(ref request, ref callSettings);
return(_callGetDeployment.Async(request, callSettings));
}
private (Deployment deployment, NugetFeed feed) GetDeployment(ObjectId id)
{
var request = new GetDeploymentRequest(id);
var response = _mediator.Send(request).Result;
return(response.Deployment, response.Feed);
}
/// <summary>
/// Gets a deployment by identifier.
/// </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>
public async Task <GetDeploymentResponse> GetDeployment(GetDeploymentRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called getDeployment");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/deployments/{deploymentId}".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);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage);
}
return(Converter.FromHttpResponseMessage <GetDeploymentResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"GetDeployment failed with error: {e.Message}");
throw;
}
}
public static Deployment GetDeployment(GetDeploymentRequest request)
{
return(ExceptionHandler.HandleGrpcCall(() =>
{
var response = deploymentServiceClient.GetDeployment(request);
return response.Deployment;
}));
}
/// <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 <GetDeploymentRequest, GetDeploymentResponse> ForDeployment(GetDeploymentRequest request, WaiterConfiguration config, params Deployment.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetDeploymentRequest, GetDeploymentResponse>(
request,
request => client.GetDeployment(request),
response => targetStates.Contains(response.Deployment.LifecycleState.Value),
targetStates.Contains(Deployment.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetDeploymentRequest, GetDeploymentResponse>(config, agent));
}
public static void RemoveDeploymentTag(GetDeploymentRequest request, string tag)
{
ExceptionHandler.HandleGrpcCall(() =>
{
var deployment = GetDeployment(request);
if (deployment.Tag.Contains(tag))
{
deployment.Tag.Remove(tag);
UpdateDeployment(deployment);
}
});
}
/// <summary>Snippet for GetDeployment</summary>
public void GetDeploymentRequestObject()
{
// Snippet: GetDeployment(GetDeploymentRequest, CallSettings)
// Create client
DeploymentsClient deploymentsClient = DeploymentsClient.Create();
// Initialize request argument(s)
GetDeploymentRequest request = new GetDeploymentRequest
{
DeploymentName = DeploymentName.FromProjectLocationAgentEnvironmentDeployment("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]", "[DEPLOYMENT]"),
};
// Make the request
Deployment response = deploymentsClient.GetDeployment(request);
// End snippet
}
/// <summary>Snippet for GetDeployment</summary>
public void GetDeploymentRequestObject()
{
// Snippet: GetDeployment(GetDeploymentRequest, CallSettings)
// Create client
GSuiteAddOnsClient gSuiteAddOnsClient = GSuiteAddOnsClient.Create();
// Initialize request argument(s)
GetDeploymentRequest request = new GetDeploymentRequest
{
DeploymentName = DeploymentName.FromProjectDeployment("[PROJECT]", "[DEPLOYMENT]"),
};
// Make the request
Deployment response = gSuiteAddOnsClient.GetDeployment(request);
// End snippet
}
public static void SetMaxWorkerCapacity(GetDeploymentRequest request, string workerType, int maxWorkerCapacity)
{
ExceptionHandler.HandleGrpcCall(() =>
{
var deployment = GetDeployment(request);
foreach (var workerCapacity in deployment.WorkerConnectionCapacities)
{
if (workerCapacity.WorkerType == workerType)
{
workerCapacity.MaxCapacity = maxWorkerCapacity;
}
}
UpdateDeployment(deployment);
});
}
public static int GetCurrentWorkerCapacity(GetDeploymentRequest request, string workerType)
{
return(ExceptionHandler.HandleGrpcCall(() =>
{
var deployment = GetDeployment(request);
foreach (var workerCapacity in deployment.WorkerConnectionCapacities)
{
if (workerCapacity.WorkerType == workerType)
{
return workerCapacity.MaxCapacity - workerCapacity.RemainingCapacity;
}
}
throw new ArgumentException($"Couldn't find worker type {workerType} in deployment {deployment.Name}");
}));
}
/// <summary>Snippet for GetDeploymentAsync</summary>
public async Task GetDeploymentRequestObjectAsync()
{
// Snippet: GetDeploymentAsync(GetDeploymentRequest, CallSettings)
// Additional: GetDeploymentAsync(GetDeploymentRequest, CancellationToken)
// Create client
GSuiteAddOnsClient gSuiteAddOnsClient = await GSuiteAddOnsClient.CreateAsync();
// Initialize request argument(s)
GetDeploymentRequest request = new GetDeploymentRequest
{
DeploymentName = DeploymentName.FromProjectDeployment("[PROJECT]", "[DEPLOYMENT]"),
};
// Make the request
Deployment response = await gSuiteAddOnsClient.GetDeploymentAsync(request);
// End snippet
}
public static void AddDeploymentTags(GetDeploymentRequest request, IEnumerable <string> tags)
{
ExceptionHandler.HandleGrpcCall(() =>
{
var deployment = GetDeployment(request);
foreach (var tag in tags)
{
if (!deployment.Tag.Contains(tag))
{
deployment.Tag.Add(tag);
}
}
UpdateDeployment(deployment);
});
}
/// <summary>Snippet for GetDeploymentAsync</summary>
public async Task GetDeploymentRequestObjectAsync()
{
// Snippet: GetDeploymentAsync(GetDeploymentRequest, CallSettings)
// Additional: GetDeploymentAsync(GetDeploymentRequest, CancellationToken)
// Create client
DeploymentsClient deploymentsClient = await DeploymentsClient.CreateAsync();
// Initialize request argument(s)
GetDeploymentRequest request = new GetDeploymentRequest
{
DeploymentName = DeploymentName.FromProjectLocationAgentEnvironmentDeployment("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]", "[DEPLOYMENT]"),
};
// Make the request
Deployment response = await deploymentsClient.GetDeploymentAsync(request);
// End snippet
}
public static void UpdateDeploymentTag(GetDeploymentRequest request, string tagPrefix, string tagValue)
{
ExceptionHandler.HandleGrpcCall(() =>
{
var deployment = GetDeployment(request);
var tags = deployment.Tag.ToList();
foreach (var tag in tags)
{
if (tag.StartsWith(tagPrefix))
{
deployment.Tag.Remove(tag);
}
}
deployment.Tag.Add($"{tagPrefix}_{tagValue}");
UpdateDeployment(deployment);
});
}
private void HandleOutput(GetDeploymentRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForDeployment(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetDeployment(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.Deployment);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetDeploymentRequest request;
try
{
request = new GetDeploymentRequest
{
DeploymentId = DeploymentId,
OpcRequestId = OpcRequestId
};
HandleOutput(request);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
internal static GetDeploymentResponse GetDeployment(string deploymentId, string region)
{
try
{
GetDeploymentRequest request = new GetDeploymentRequest()
{
DeploymentId = deploymentId
};
AmazonCodeDeployClient client = string.IsNullOrEmpty(region) ?
new AmazonCodeDeployClient() :
new AmazonCodeDeployClient(RegionEndpoint.GetBySystemName(region));
Task <GetDeploymentResponse> response = client.GetDeploymentAsync(request);
Task.WaitAll(new Task[] { response });
return(response.Result);
}
catch (System.Exception e)
{
Log.Error($"{e.GetBaseException().GetType().Name}: {e.Message}");
return(null);
}
}
public void GetDeployment()
{
moq::Mock <Deployments.DeploymentsClient> mockGrpcClient = new moq::Mock <Deployments.DeploymentsClient>(moq::MockBehavior.Strict);
GetDeploymentRequest request = new GetDeploymentRequest
{
DeploymentName = DeploymentName.FromProjectLocationAgentEnvironmentDeployment("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]", "[DEPLOYMENT]"),
};
Deployment expectedResponse = new Deployment
{
DeploymentName = DeploymentName.FromProjectLocationAgentEnvironmentDeployment("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]", "[DEPLOYMENT]"),
FlowVersionAsVersionName = VersionName.FromProjectLocationAgentFlowVersion("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]"),
State = Deployment.Types.State.Succeeded,
Result = new Deployment.Types.Result(),
StartTime = new wkt::Timestamp(),
EndTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.GetDeployment(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
DeploymentsClient client = new DeploymentsClientImpl(mockGrpcClient.Object, null);
Deployment response = client.GetDeployment(request.Name);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public SpatialOSReceiveHandler(Connection connection, GetDeploymentRequest request)
{
this.connection = connection;
this.request = request;
SetupHandlers();
}
private void UpdatePlayerCount(GetDeploymentRequest getDeploymentRequest)
{
var playerCount = DeploymentModifier.GetCurrentWorkerCapacity(getDeploymentRequest, sessionConfig.ClientType);
DeploymentModifier.UpdateDeploymentTag(getDeploymentRequest, Tags.Players, playerCount.ToString());
}
/// <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 <GetDeploymentRequest, GetDeploymentResponse> ForDeployment(GetDeploymentRequest request, params Deployment.LifecycleStateEnum[] targetStates)
{
return(this.ForDeployment(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates));
}
/// <summary> /// Retrieves the specified [Deployment][google.cloud.dialogflow.cx.v3.Deployment]. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="callSettings">If not null, applies overrides to this RPC call.</param> /// <returns>The RPC response.</returns> public virtual Deployment GetDeployment(GetDeploymentRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException();
/// <summary> /// Retrieves the specified [Deployment][google.cloud.dialogflow.cx.v3.Deployment]. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="callSettings">If not null, applies overrides to this RPC call.</param> /// <returns>A Task containing the RPC response.</returns> public virtual stt::Task <Deployment> GetDeploymentAsync(GetDeploymentRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException();
/// <summary> /// Retrieves the specified [Deployment][google.cloud.dialogflow.cx.v3.Deployment]. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="cancellationToken">A <see cref="st::CancellationToken"/> to use for this RPC.</param> /// <returns>A Task containing the RPC response.</returns> public virtual stt::Task <Deployment> GetDeploymentAsync(GetDeploymentRequest request, st::CancellationToken cancellationToken) => GetDeploymentAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
partial void Modify_GetDeploymentRequest(ref GetDeploymentRequest request, ref gaxgrpc::CallSettings settings);
