internal virtual GetOperationResponse GetOperation(GetOperationRequest request)
{
var marshaller = GetOperationRequestMarshaller.Instance;
var unmarshaller = GetOperationResponseUnmarshaller.Instance;
return(Invoke <GetOperationRequest, GetOperationResponse>(request, marshaller, unmarshaller));
}
public override async Task <GetOperationResponse> GetOperation(GetOperationRequest request,
ServerCallContext context)
{
_logger.LogInformation($"Received 'Get operation' (id: {request.Id}) request from: {context.Peer}");
return(Map(await _operationsService.GetAsync(request.Id)));
}
public async stt::Task GetOperationRequestObjectAsync()
{
moq::Mock <Operations.OperationsClient> mockGrpcClient = new moq::Mock <Operations.OperationsClient>(moq::MockBehavior.Strict);
GetOperationRequest request = new GetOperationRequest
{
Name = "name1c9368b0",
};
Operation expectedResponse = new Operation
{
Name = "name1c9368b0",
Metadata = new wkt::Any(),
Done = true,
Error = new gr::Status(),
Response = new wkt::Any(),
};
mockGrpcClient.Setup(x => x.GetOperationAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Operation>(stt::Task.FromResult(expectedResponse), null, null, null, null));
OperationsClient client = new OperationsClientImpl(mockGrpcClient.Object, null);
Operation responseCallSettings = await client.GetOperationAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Operation responseCancellationToken = await client.GetOperationAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetOperationRequest request;
try
{
request = new GetOperationRequest
{
RegistryId = RegistryId,
ConnectionKey = ConnectionKey,
SchemaResourceName = SchemaResourceName,
OperationResourceName = OperationResourceName,
OpcRequestId = OpcRequestId,
EndpointId = EndpointId
};
response = client.GetOperation(request).GetAwaiter().GetResult();
WriteOutput(response, response.Operation);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task <IActionResult> Produce(GetOperationRequest request)
{
var validatorActionResult = await _validationArrangement.Validate(request);
var actionResult = await _operationArrangement.Process(request, validatorActionResult);
return(actionResult);
}
public GetOperationResponse GetOperation(GetOperationRequest request)
{
return(DataContext.KeyOperationConfigs.Where(x => x.Id == request.Id)
.Include(x => x.Kpi)
.Include(x => x.KeyOperationGroup)
.FirstOrDefault()
.MapTo <GetOperationResponse>());
}
/// <summary>
/// Initiates the asynchronous execution of the GetOperation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetOperation 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/servicediscovery-2017-03-14/GetOperation">REST API Reference for GetOperation Operation</seealso>
public virtual Task <GetOperationResponse> GetOperationAsync(GetOperationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = GetOperationRequestMarshaller.Instance;
var unmarshaller = GetOperationResponseUnmarshaller.Instance;
return(InvokeAsync <GetOperationRequest, GetOperationResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public GetOperationQuery Map(GetOperationRequest request)
{
var id = new Guid(request.RouteId);
var result = new GetOperationQuery(id);
return(result);
}
internal virtual GetOperationResponse GetOperation(GetOperationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetOperationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetOperationResponseUnmarshaller.Instance;
return(Invoke <GetOperationResponse>(request, options));
}
public async Task <IActionResult> Get([FromRoute] GetOperationFromRoute route,
[FromQuery] GetOperationFromQuery query)
{
var request = new GetOperationRequest(route, query);
var result = await _apiResult.Produce(request);
return(result);
}
/// <summary>
/// Initiates the asynchronous execution of the GetOperation operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetOperation 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/servicediscovery-2017-03-14/GetOperation">REST API Reference for GetOperation Operation</seealso>
public virtual Task <GetOperationResponse> GetOperationAsync(GetOperationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetOperationRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetOperationResponseUnmarshaller.Instance;
return(InvokeAsync <GetOperationResponse>(request, options, cancellationToken));
}
/// <summary>Snippet for GetOperation</summary>
public void GetOperationRequestObject()
{
// Snippet: GetOperation(GetOperationRequest, CallSettings)
// Create client
OperationsClient operationsClient = OperationsClient.Create();
// Initialize request argument(s)
GetOperationRequest request = new GetOperationRequest {
Name = "",
};
// Make the request
Operation response = operationsClient.GetOperation(request);
// End snippet
}
/// <summary>Snippet for GetOperationAsync</summary>
public async Task GetOperationAsync_RequestObject()
{
// Snippet: GetOperationAsync(GetOperationRequest,CallSettings)
// Create client
OperationsClient operationsClient = await OperationsClient.CreateAsync();
// Initialize request argument(s)
GetOperationRequest request = new GetOperationRequest
{
Name = "",
};
// Make the request
Operation response = await operationsClient.GetOperationAsync(request);
// End snippet
}
public async Task<IActionResult> Process(GetOperationRequest request, IValidatorActionResult validatorActionResult)
{
IActionResult actionResult;
if (validatorActionResult.Result == null)
{
var call = _cqsMapper.Map(request);
var result = await _mediator.Send(call);
actionResult = result.IsFailure ? _apiResponse.Fail(result)
: _apiResponse.Ok(((Result<OperationModel>)result).Value, ((Result<OperationModel>)result).Version.ToString());
}
else
{
actionResult = validatorActionResult.Result;
}
return actionResult;
}
public async Task GetOperationAsync2()
{
Mock <Operations.OperationsClient> mockGrpcClient = new Mock <Operations.OperationsClient>(MockBehavior.Strict);
GetOperationRequest request = new GetOperationRequest
{
Name = "name3373707",
};
Operation expectedResponse = new Operation
{
Name = "name2-1052831874",
Done = true,
};
mockGrpcClient.Setup(x => x.GetOperationAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Operation>(Task.FromResult(expectedResponse), null, null, null, null));
OperationsClient client = new OperationsClientImpl(mockGrpcClient.Object, null);
Operation response = await client.GetOperationAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void GetOperation2()
{
Mock <Operations.OperationsClient> mockGrpcClient = new Mock <Operations.OperationsClient>(MockBehavior.Strict);
GetOperationRequest request = new GetOperationRequest
{
Name = "name3373707",
};
Operation expectedResponse = new Operation
{
Name = "name2-1052831874",
Done = true,
};
mockGrpcClient.Setup(x => x.GetOperation(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
OperationsClient client = new OperationsClientImpl(mockGrpcClient.Object, null);
Operation response = client.GetOperation(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public override async Task <GetOperationResponse> GetOperations(GetOperationRequest request, ServerCallContext context)
{
var operations = await _operationRepository.GetAsync(new DepositWalletKey(
request.WalletKey.BlockchainAssetId,
request.WalletKey.BlockchainId,
request.WalletKey.WalletAddress), request.Skip, request.Take);
var response = new GetOperationResponse();
if (operations != null && operations.Any())
{
response.Operations.AddRange(operations.Select(x =>
new OperationResponse()
{
WalletKey = request.WalletKey,
BalanceChange = x.BalanceChange.ToString(),
OperationId = x.OperationId,
Block = x.Block
}));
}
return(response);
}
public void GetOperation()
{
moq::Mock <Operations.OperationsClient> mockGrpcClient = new moq::Mock <Operations.OperationsClient>(moq::MockBehavior.Strict);
GetOperationRequest request = new GetOperationRequest
{
Name = "name1c9368b0",
};
Operation expectedResponse = new Operation
{
Name = "name1c9368b0",
Metadata = new wkt::Any(),
Done = true,
Error = new gr::Status(),
Response = new wkt::Any(),
};
mockGrpcClient.Setup(x => x.GetOperation(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
OperationsClient client = new OperationsClientImpl(mockGrpcClient.Object, null);
Operation response = client.GetOperation(request.Name);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <OperationUpdate> GetOperation(GetOperationRequest request)
{
try
{
using var activity = MyTelemetry.StartActivity($"Use DB context {DatabaseContext.Schema}")
?.AddTag("db-schema", DatabaseContext.Schema);
await using var ctx = DatabaseContext.Create(_dbContextOptionsBuilder);
var operation = await ctx.OperationHistory.FirstOrDefaultAsync(e => e.WalletId == request.WalletId && e.AssetId == request.AssetId && request.OperationId == e.OperationId);
return(operation != null
? new OperationUpdate(operation)
: new OperationUpdate());
}
catch (Exception e)
{
_logger.LogError(e,
"Cannot get OperationUpdate for walletId: {walletId}, assetId: {assetId}, operationId: {operationId}",
request.WalletId, request.AssetId, request.OperationId);
e.WriteToActivity();
request.AddToActivityAsJsonTag("request");
throw;
}
}
public override async Task <Operation> GetOperation(GetOperationRequest request, ServerCallContext context)
{
var playerIdentity = AuthHeaders.ExtractPlayerId(context);
if (!string.Equals(request.Name, playerIdentity))
{
throw new RpcException(new Status(StatusCode.PermissionDenied,
"Fetching another player's operation is forbidden."));
}
PlayerJoinRequest joinRequest;
using (var memClient = _memoryStoreClientManager.GetClient())
{
try
{
joinRequest = await memClient.GetAsync <PlayerJoinRequest>(request.Name) ??
throw new EntryNotFoundException(request.Name);
if (joinRequest.IsComplete())
{
using (var tx = memClient.CreateTransaction())
{
tx.DeleteAll(joinRequest.Yield());
}
}
}
catch (EntryNotFoundException e)
{
Reporter.OperationStateNotFoundInc();
Log.Warning($"Join request for {e.Id} does not exist");
throw new RpcException(new Status(StatusCode.NotFound, "requested player does not exist"));
}
catch (TransactionAbortedException)
{
Reporter.TransactionAbortedInc("GetOperation");
Log.Warning("Transaction for operation deletion was aborted");
throw new RpcException(new Status(StatusCode.Unavailable,
"deletion aborted due to concurrent modification; safe to retry"));
}
}
var op = new Operation
{
Name = joinRequest.PlayerIdentity,
Done = joinRequest.IsComplete()
};
if (!op.Done)
{
Reporter.OperationStateInc(MatchState.Requested);
return(op);
}
switch (joinRequest.State)
{
case MatchState.Matched:
op.Response = CreateJoinResponse(joinRequest);
break;
case MatchState.Error:
op.Error = new Google.Rpc.Status
{
Code = (int)Google.Rpc.Code.Unknown,
Message = "the join request encountered an error"
};
break;
}
Reporter.OperationStateInc(joinRequest.State);
Log.Information($"Join request for {op.Name} done in state {joinRequest.State}.");
return(op);
}
