/// <summary>Send message async
/// </summary>
public async ValueTask <ResponseMessage> SendMessageAsync(RequestMessage request, int timeoutMillis = 5000)
{
if (_clientChannel == null)
{
throw new ArgumentNullException("Socket client should connect first!");
}
if (!_clientChannel.IsWritable)
{
_manualResetEventSlim.Wait();
}
var sequence = Interlocked.Increment(ref _sequence);
var messageReqPacket = new MessageReqPacket()
{
Sequence = sequence,
Code = request.Code,
Body = request.Body,
};
var tcs = new TaskCompletionSource <ResponseMessage>();
var responseFuture = new ResponseFuture(request.Code, timeoutMillis, tcs);
if (!_responseFutureDict.TryAdd(sequence, responseFuture))
{
throw new Exception($"Add 'ResponseFuture' failed. Sequence:{sequence}");
}
await _clientChannel.WriteAndFlushAsync(messageReqPacket);
return(await tcs.Task);
}
public Task <RemotingResponse> InvokeAsync(RemotingRequest request, int timeoutMillis)
{
EnsureClientStatus();
request.Type = RemotingRequestType.Async;
var taskCompletionSource = new TaskCompletionSource <RemotingResponse>();
var responseFuture = new ResponseFuture(request, timeoutMillis, taskCompletionSource);
if (!_responseFutureDict.TryAdd(request.Sequence, responseFuture))
{
throw new ResponseFutureAddFailedException(request.Sequence);
}
_clientSocket.QueueMessage(RemotingUtils.BuildRequestMessage(request));
return(taskCompletionSource.Task);
}
internal virtual object Invoke(StateMachine stateMachine, System.Reflection.MethodInfo method, object arg)
{
if (method.Name.Equals("toString"))
{
return(_me.ToString());
}
if (method.Name.Equals("equals"))
{
return((( StateMachineProxyHandler )Proxy.getInvocationHandler(arg)).StateMachineProxyFactory.me.Equals(_me));
}
string conversationId = _conversations.NextConversationId;
try
{
MessageType typeAsEnum = ( MessageType )Enum.valueOf(stateMachine.MessageType, method.Name);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.cluster.com.message.Message<?> message = org.neo4j.cluster.com.message.Message.internal(typeAsEnum, arg);
Message <object> message = Message.@internal(typeAsEnum, arg);
if (_me != null)
{
message.SetHeader(Message.HEADER_CONVERSATION_ID, conversationId).setHeader(Message.HEADER_CREATED_BY, _me.ToString());
}
if (method.ReturnType.Equals(Void.TYPE))
{
_stateMachines.process(message);
return(null);
}
else
{
ResponseFuture future = new ResponseFuture(conversationId, typeAsEnum, _responseFutureMap);
_responseFutureMap[conversationId] = future;
_log.debug("Added response future for conversation id %s", conversationId);
_stateMachines.process(message);
return(future);
}
}
catch (System.ArgumentException)
{
throw new System.InvalidOperationException("No state machine can handle the method " + method.Name);
}
}
public async ValueTask <ResponseMessage> SendMessageAsync(RequestMessage request, int timeoutMillis = 3000)
{
var sequence = Interlocked.Increment(ref _sequence);
var messageReqPacket = new MessageReqPacket()
{
Sequence = sequence,
Code = request.Code,
Body = request.Body,
};
var tcs = new TaskCompletionSource <ResponseMessage>();
var responseFuture = new ResponseFuture(request.Code, timeoutMillis, tcs);
if (!_responseFutureDict.TryAdd(sequence, responseFuture))
{
throw new Exception($"Add 'ResponseFuture' failed. Sequence:{sequence}");
}
//await _easyClient.SendAsync<MessageReqPacket>();
//await _clientChannel.WriteAndFlushAsync(messageReqPacket);
return(await tcs.Task);
}
public override bool Process <T1>(Message <T1> message)
{
if (_responseFutureMap.Count > 0)
{
if (!message.HasHeader(Message.HEADER_TO))
{
string conversationId = message.GetHeader(Message.HEADER_CONVERSATION_ID);
ResponseFuture future = _responseFutureMap[conversationId];
if (future != null)
{
if (future.setPotentialResponse(message))
{
_responseFutureMap.Remove(conversationId);
}
}
else
{
_log.warn("Unable to find the client (with the conversation id %s) waiting for the response %s.", conversationId, message);
}
}
}
return(true);
}
public virtual void CancelRequest()
{
// ResponseFuture.Cancel(true);
ResponseFuture.Dispose();
NotifyActionEvent(QQActionEventType.EVT_CANCELED, null);
}
public async Task <IResponse> RequestAsync(IRequest request, DeviceOperationScope scope, AsyncOperationInfo operationInfo)
{
IResponse result = null;
await clearUnreadBytesAsync();
var requestData = request.Serialized.ToArray();
var sendRequestOk = await tryWriteToPort(requestData, operationInfo);
if (!sendRequestOk)
{
result = request.BuildErrorResponse(RequestStatus.CONNECTION_INTERFACE_ERROR);
}
else
{
await Logger.LogRequestAsync(requestData);
try
{
using (var future = new ResponseFuture(_port.Pipe, request.Timeout, operationInfo))
{
result = await request.DeserializeResponseAsync(future, operationInfo);
}
}
catch (TimeoutException)
{
result = request.BuildErrorResponse(RequestStatus.READ_TIMEOUT);
}
catch (IOException)
{
result = request.BuildErrorResponse(RequestStatus.CONNECTION_INTERFACE_ERROR);
}
catch (OperationCanceledException)
{
result = request.BuildErrorResponse(RequestStatus.CONNECTION_INTERFACE_ERROR);
}
catch
{
result = request.BuildErrorResponse(RequestStatus.UNKNOWN_ERROR);
}
}
return(result);
async Task clearUnreadBytesAsync()
{
var clearOperation = await CommonUtils.TryAsync(async() => await _port.Pipe.ClearReadBufferAsync(operationInfo));
if (clearOperation.Ok)
{
if (clearOperation.Result.BytesRead != 0)
{
Logger.LogWarning(null, $"Обнаружены несчитанные данные в буфере приема! Это означает, что устройство отправило больше данных чем предполагалось. -NLДлина: {clearOperation.Result.Data.Count()} -NLДанные={clearOperation.Result.Data.Take(1000).Select(b => b.ToString("X2")).AsString(" ")}");
}
}
else
{
Logger.LogError(null, $"Ошибка очистки буфера чтения порта. Порт был закрыт?");
}
}
}
