public async ValueTask <RPCResponseMessage> ProcessRequestAsync(RPCRequestMessage request, Guid clientId, MethodDescriptor mDesc, CancellationToken cancellationToken)
{
var response = RPCResponseMessage.Retrieve(request);
var threadClientIdIndex = Environment.CurrentManagedThreadId % MaxSupportedThreadCounts;
_threadClientId[threadClientIdIndex] = clientId;
ConnectionCancellationToken = cancellationToken;
var initTime = Stopwatch.GetTimestamp();
try
{
var results = mDesc.Method(ServiceInstance, request.Parameters);
if (mDesc.ReturnIsTask)
{
var resultTask = (Task)results;
await resultTask.ConfigureAwait(false);
if (mDesc.ReturnTaskResult != null)
{
response.ReturnValue = mDesc.ReturnTaskResult.GetValue(resultTask);
}
else
{
response.ReturnValue = null;
}
}
else
{
response.ReturnValue = results;
}
}
catch (TargetInvocationException ex)
{
Core.Log.Error("Error calling the Method: {0} with Parameters: [{1}], on the Service: {2}", mDesc?.Name, mDesc?.Parameters?.Select(p => p.Name + "(" + p.Type + ")").Join(","), Descriptor?.Name);
Core.Log.Error("Trying to call with the following parameters: {0}", request?.Parameters?.Select(s => s?.GetType().FullName ?? "(null)").Join(","));
Core.Log.Write(ex);
response.Exception = new SerializableException(ex.InnerException);
}
catch (Exception ex)
{
Core.Log.Error("Error calling the Method: {0} with Parameters: [{1}], on the Service: {2}", mDesc?.Name, mDesc?.Parameters?.Select(p => p.Name + "(" + p.Type + ")").Join(","), Descriptor?.Name);
Core.Log.Error("Trying to call with the following parameters: {0}", request?.Parameters?.Select(s => s?.GetType().FullName ?? "(null)").Join(","));
Core.Log.Write(ex);
response.Exception = new SerializableException(ex);
}
_threadClientId[threadClientIdIndex] = Guid.Empty;
var execTime = (Stopwatch.GetTimestamp() - initTime) * 1000d / Stopwatch.Frequency;
mDesc.Counter.Add(execTime);
return(response);
}
private void ClientOnOnMessageReceived(RpcClient rpcClient1, RPCMessage rpcMessage)
{
switch (rpcMessage)
{
case RPCResponseMessage responseMessage:
if (!_messageResponsesHandlers.TryRemove(responseMessage.RequestMessageId, out var value))
{
return;
}
value.Message = responseMessage;
value.Event.Set();
break;
case RPCEventMessage eventMessage:
if (!_previousMessages.TryGetValue(eventMessage.MessageId, out _))
{
_previousMessages.TryAdd(eventMessage.MessageId, null);
var edea = EventDataEventArgs.Retrieve(eventMessage.ServiceName, eventMessage.EventName, eventMessage.EventArgs);
OnEventReceived?.Invoke(this, edea);
EventDataEventArgs.Store(edea);
}
break;
case RPCPushMessage pushMessage:
if (!_previousMessages.TryGetValue(pushMessage.MessageId, out _))
{
_previousMessages.TryAdd(pushMessage.MessageId, null);
var evArgs = ReferencePool <EventArgs <RPCPushMessage> > .Shared.New();
evArgs.Item1 = pushMessage;
OnPushMessageReceived?.Invoke(this, evArgs);
evArgs.Item1 = null;
ReferencePool <EventArgs <RPCPushMessage> > .Shared.Store(evArgs);
}
break;
case RPCError errorMessage:
var respMsg = RPCResponseMessage.Retrieve(errorMessage);
foreach (var mHandler in _messageResponsesHandlers.ToArray())
{
mHandler.Value.Message = respMsg;
mHandler.Value.Event.Set();
_messageResponsesHandlers.TryRemove(mHandler.Key, out _);
}
break;
}
}
public RPCResponseMessage ProcessRequest(RPCRequestMessage request, Guid clientId, MethodDescriptor mDesc, CancellationToken cancellationToken)
{
var response = RPCResponseMessage.Retrieve(request);
try
{
lock (_threadClientId) _threadClientId[Environment.CurrentManagedThreadId] = clientId;
ConnectionCancellationToken = cancellationToken;
var results = mDesc.Method(ServiceInstance, request.Parameters);
if (results is Task resultTask)
{
resultTask.WaitAsync();
var type = results.GetType();
if (type.GenericTypeArguments.Length > 0)
{
var resultProperty = TaskResultsProperties.GetOrAdd(results.GetType(), mType => mType.GetProperty("Result").GetFastPropertyInfo());
response.ReturnValue = resultProperty.GetValue(resultTask);
}
else
{
response.ReturnValue = null;
}
}
else
{
response.ReturnValue = results;
}
}
catch (TargetInvocationException ex)
{
Core.Log.Error("Error calling the Method: {0} with Parameters: [{1}], on the Service: {2}", mDesc?.Name, mDesc?.Parameters?.Select(p => p.Name + "(" + p.Type + ")").Join(","), Descriptor?.Name);
Core.Log.Error("Trying to call with the following parameters: {0}", request?.Parameters?.Select(s => s?.GetType().FullName ?? "(null)").Join(","));
Core.Log.Write(ex);
response.Exception = new SerializableException(ex.InnerException);
}
catch (Exception ex)
{
Core.Log.Error("Error calling the Method: {0} with Parameters: [{1}], on the Service: {2}", mDesc?.Name, mDesc?.Parameters?.Select(p => p.Name + "(" + p.Type + ")").Join(","), Descriptor?.Name);
Core.Log.Error("Trying to call with the following parameters: {0}", request?.Parameters?.Select(s => s?.GetType().FullName ?? "(null)").Join(","));
Core.Log.Write(ex);
response.Exception = new SerializableException(ex);
}
return(response);
}
private void ClientOnOnMessageReceived(RpcClient rpcClient1, RPCMessage rpcMessage)
{
switch (rpcMessage)
{
case RPCResponseMessage responseMessage:
if (!_messageResponsesHandlers.TryRemove(responseMessage.RequestMessageId, out var value))
{
return;
}
value.Message = responseMessage;
value.Event.Set();
break;
case RPCEventMessage eventMessage:
_previousMessages.GetOrAdd(eventMessage.MessageId, mId =>
{
OnEventReceived?.InvokeAsync(this, new EventDataEventArgs(eventMessage.ServiceName, eventMessage.EventName, eventMessage.EventArgs));
return(null);
});
break;
case RPCPushMessage pushMessage:
_previousMessages.GetOrAdd(pushMessage.MessageId, mId =>
{
OnPushMessageReceived?.InvokeAsync(this, new EventArgs <RPCPushMessage>(pushMessage));
return(null);
});
break;
case RPCError errorMessage:
var respMsg = new RPCResponseMessage {
Exception = errorMessage.Exception
};
foreach (var mHandler in _messageResponsesHandlers.ToArray())
{
mHandler.Value.Message = respMsg;
mHandler.Value.Event.Set();
_messageResponsesHandlers.TryRemove(mHandler.Key, out var _);
}
break;
}
}
