private void OnProcessMessage(object data)
{
object[] array = (object[])data;
IMethodHandler handler = (IMethodHandler)array[0];
ISession context = (ISession)array[1];
object message = array[2];
Session.Current = context;
try
{
MethodContext mc = new MethodContext(mApplication, context, new object[] { context, message }, handler);
mc.Execute();
if (mc.Result != null)
{
mApplication.Server.Send(mc.Result, context.Channel);
}
}
catch (Exception e_)
{
"{0} invoke error ".Log4Error(e_, handler.ToString());
context.Channel.InvokeError(e_);
}
finally
{
Session.Current = null;
}
}
public MethodContext(IApplication app, ISession session, object[] parameters, IMethodHandler handler)
{
Application = app;
Session = session;
Parameters = parameters;
Handler = handler;
}
/// <inheritdoc/>
public Task <byte[]> InvokeAsync(byte[] payload, string contentType,
IMethodHandler context)
{
// Handle response from device method
var response = _serializer.Deserialize <HttpTunnelResponseModel>(payload);
if (_outstanding.TryRemove(response.RequestId, out var request))
{
var httpResponse = new HttpResponseMessage((HttpStatusCode)response.Status)
{
Content = response.Payload == null ? null :
new ByteArrayContent(response.Payload)
};
if (response.Headers != null)
{
foreach (var header in response.Headers)
{
httpResponse.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
}
request.Completion.TrySetResult(httpResponse);
request.Dispose();
}
return(Task.FromResult(new byte[0]));
}
public MethodContext(IApplication app, ISession session, object[] parameters, IMethodHandler handler)
{
Application = app;
Session = session;
Parameters = parameters;
Handler = handler;
}
/// <inheritdoc/>
public async Task <byte[]> InvokeAsync(byte[] payload, string contentType,
IMethodHandler handler)
{
var request = _serializer.Deserialize <MethodChunkModel>(payload);
ChunkProcessor processor;
if (request.Handle != null)
{
if (!_requests.TryGetValue(request.Handle, out processor))
{
throw new MethodCallStatusException(
(int)HttpStatusCode.RequestTimeout, $"No handle {request.Handle}");
}
}
else
{
var handle = Interlocked.Increment(ref _requestCounter).ToString();
processor = new ChunkProcessor(this, handle, request.MethodName,
request.ContentType, request.ContentLength, request.MaxChunkLength,
request.Timeout);
if (!_requests.TryAdd(handle, processor))
{
throw new MethodCallStatusException((int)HttpStatusCode.InternalServerError,
$"Adding handle {handle} failed.");
}
}
var response = await processor.ProcessAsync(handler, request);
return(_serializer.SerializeToBytes(response).ToArray());
}
public void ProcessMessage(object message, ISession context)
{
Events.EventMessageProcessArgs mpa = new Events.EventMessageProcessArgs();
mpa.Application = this.mApplication;
mpa.Cancel = false;
mpa.Session = context;
mpa.Message = message;
OnMessageExecting(mpa);
if (mpa.Cancel)
{
return;
}
IMethodHandler handler = null;
if (mHandlers.TryGetValue(message.GetType(), out handler))
{
object data = new object[] { handler, context, message };
if (handler.UseThreadPool)
{
System.Threading.ThreadPool.QueueUserWorkItem(OnProcessMessage, data);
}
else
{
OnProcessMessage(data);
}
}
else
{
"{0} messgae action notfound".Log4Error(message.GetType());
}
}
public void AddMethodHandler(ObjectPath?path, string interfaceName, IMethodHandler handler)
{
ThrowIfDisposed();
if (string.IsNullOrEmpty(interfaceName))
{
throw new ArgumentNullException(nameof(interfaceName));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
lock (_gate)
{
if (path.HasValue)
{
var pathParts = path.Value.Decomposed;
MethodHandlerPathPart pathHandlers = RootPath;
foreach (var part in pathParts)
{
if (!pathHandlers.OurSubParts.TryGetValue(part, out MethodHandlerPathPart next))
{
next = new MethodHandlerPathPart(pathHandlers, part);
pathHandlers.AddOurSubPart(part, next);
}
pathHandlers = next;
}
pathHandlers.OurInterfaceHandlers[interfaceName] = handler;
}
else
{
GlobalInterfaceHandlers[interfaceName] = handler;
}
}
}
/// <summary>
/// Create server
/// </summary>
/// <param name="handler"></param>
/// <param name="logger"></param>
public ChunkMethodServer(IMethodHandler handler, ILogger logger)
{
_handler = handler ?? throw new ArgumentNullException(nameof(handler));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_requests = new ConcurrentDictionary <string, ChunkProcessor>();
_timer = new Timer(_ => OnTimer(), null,
kTimeoutCheckInterval, kTimeoutCheckInterval);
}
/// <summary>
/// 设置方法解析器。
/// </summary>
/// <param name="methodName"></param>
/// <param name="handler"></param>
public static void SetMethodHandler(string methodName, IMethodHandler handler)
{
PublicHelper.CheckNull(methodName, nameof(methodName));
PublicHelper.CheckNull(handler, nameof(handler));
lock (SqlGenerator.MethodHandlers)
{
SqlGenerator.MethodHandlers[methodName] = handler;
}
}
async void HandleMethodCall(Message methodCall, IMessageStream peer)
{
bool pathKnown = false;
IMethodHandler methodHandler = null;
if (methodCall.Header.Path.HasValue && !string.IsNullOrEmpty(methodCall.Header.Interface))
{
var pathHandler = PartHandlerForPath(methodCall.Header.Path.Value);
if (pathHandler != null)
{
pathKnown = true;
if (!pathHandler.InterfaceHandlers.TryGetValue(methodCall.Header.Interface, out methodHandler))
{
methodHandler = GlobalInterfaceHandlers.GetValueOrDefault(methodCall.Header.Interface);
}
if (methodHandler != null && !methodHandler.CheckExposure(methodCall.Header.Path.Value))
{
methodHandler = null;
}
}
}
if (methodHandler != null)
{
var reply = await methodHandler.HandleMethodCall(methodCall);
if (reply != null)
{
reply.Header.ReplySerial = methodCall.Header.Serial;
reply.Header.Destination = methodCall.Header.Sender;
SendMessage(reply, peer);
}
else if (methodCall.Header.ReplyExpected)
{
SendMessage(MessageHelper.ConstructReply(methodCall), peer);
}
}
else if (methodCall.Header.ReplyExpected)
{
if (!pathKnown)
{
SendErrorReply(methodCall, DBusErrors.UnknownObject, $"No objects at path {methodCall.Header.Path}", peer);
}
else
{
SendErrorReply(methodCall, DBusErrors.UnknownInterface, $"No interface {methodCall.Header.Interface} at path {methodCall.Header.Path}", peer);
}
}
}
/// <inheritdoc/>
public async Task <byte[]> InvokeAsync(byte[] payload, string contentType,
IMethodHandler handler)
{
Exception e = null;
foreach (var invoker in _invokers)
{
try {
return(await invoker.InvokeAsync(payload, contentType, handler));
}
catch (Exception ex) {
// Save last, and continue
e = ex;
}
}
_logger.Verbose(e, "Exception during method invocation.");
throw e;
}
/// <inheritdoc/>
public Task <byte[]> InvokeAsync(byte[] payload, string contentType,
IMethodHandler handler)
{
object task;
try {
object[] inputs;
if (_methodParams.Length == 0)
{
inputs = new object[0];
}
else if (_methodParams.Length == 1)
{
var data = _serializer.Deserialize(payload, _methodParams[0].ParameterType);
inputs = new[] { data };
}
else
{
var data = _serializer.Parse(payload);
inputs = _methodParams.Select(param => {
if (data.TryGetProperty(param.Name,
out var value, StringComparison.InvariantCultureIgnoreCase))
{
return(value.ConvertTo(param.ParameterType));
}
return(param.HasDefaultValue ? param.DefaultValue : null);
}).ToArray();
}
task = _controllerMethod.Invoke(_controller, inputs);
}
catch (Exception e) {
task = Task.FromException(e);
}
if (_methodTaskContinuation == null)
{
return(VoidContinuation((Task)task));
}
return((Task <byte[]>)_methodTaskContinuation.Invoke(this, new[] {
task
}));
}
public void ProcessMessage(object message, ISession context)
{
Events.EventMessageProcessArgs mpa = new Events.EventMessageProcessArgs();
mpa.Application = this.mApplication;
mpa.Cancel = false;
mpa.Session = context;
mpa.Message = message;
OnMessageExecting(mpa);
if (mpa.Cancel)
{
return;
}
IMethodHandler handler = null;
RemoteInvokeArgs invokeArgs = (RemoteInvokeArgs)context[SOA_INVOKE_TAG];
if (message is RPC.MethodCall)
{
invokeArgs = new RemoteInvokeArgs((RPC.MethodCall)message);
context[SOA_INVOKE_TAG] = invokeArgs;
}
else
{
if (invokeArgs == null)
{
if (mControllerHandlers.TryGetValue(message.GetType(), out handler))
{
object data = new object[] { handler, context, message };
if (handler.UseThreadPool)
{
System.Threading.ThreadPool.QueueUserWorkItem(OnControllerProcess, data);
}
else
{
OnControllerProcess(data);
}
}
else
{
"{0} messgae action notfound".Log4Error(message.GetType());
}
return;
}
else
{
invokeArgs.AddParameter(message);
}
}
if (invokeArgs.HasCompleted)
{
context[SOA_INVOKE_TAG] = null;
string key = invokeArgs.GetKey();
if (mSoaHandlers.TryGetValue(key, out handler))
{
object data = new object[] { handler, context, invokeArgs.Parameters, invokeArgs };
if (handler.UseThreadPool)
{
System.Threading.ThreadPool.QueueUserWorkItem(OnSOAProcess, data);
}
else
{
OnSOAProcess(data);
}
}
else
{
RPC.MethodResult result = new RPC.MethodResult();
result.Status = ResultStatus.Error;
result.Error = string.Format("{0} method not found!", key);
mApplication.Server.Send(result, context.Channel);
"{0} method notfound".Log4Error(key);
}
}
}
public LoggingMethodHandlerDecorator(
IMethodHandler <T> handler)
{
this.handler = handler;
}
public VcGenCommandMeasurementMethodInvoker(IServiceProvider serviceProvider, IMethodHandler <ClockMeasurementMessage, ObjectMethodResponse <ClockMeasureResponse> > methodHandler)
{
this.serviceProvider = serviceProvider;
this.methodHandler = methodHandler;
}
/// <summary>
/// Process request and return response
/// </summary>
/// <param name="handler"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <MethodChunkModel> ProcessAsync(IMethodHandler handler,
MethodChunkModel request)
{
var status = 200;
if (_sent == -1)
{
// Receiving
Buffer.BlockCopy(request.Payload, 0, _payload, _received,
request.Payload.Length);
_received += request.Payload.Length;
if (_received < _payload.Length)
{
// Continue upload
_lastActivity = DateTime.UtcNow;
return(new MethodChunkModel {
Handle = Handle
});
}
try {
// Process
var result = await handler.InvokeAsync(_method,
_payload.Unzip(), _contentType);
// Set response payload
_payload = result.Zip();
}
catch (MethodCallStatusException mex) {
_payload = Encoding.UTF8.GetBytes(mex.ResponsePayload).Zip();
status = mex.Result;
}
catch (Exception ex) {
// Unexpected
status = (int)HttpStatusCode.InternalServerError;
_outer._logger.Error(ex,
"Processing message resulted in unexpected error");
}
_sent = 0;
}
// Sending
var length = Math.Min(_payload.Length - _sent, _maxChunkLength);
var buffer = new byte[length];
Buffer.BlockCopy(_payload, _sent, buffer, 0, buffer.Length);
var response = new MethodChunkModel {
ContentLength = _sent == 0 ? _payload.Length : (int?)null,
Status = _sent == 0 && status != 200 ? status : (int?)null,
Payload = buffer
};
_sent += length;
if (_sent == _payload.Length)
{
// Done - remove ourselves
_outer._requests.TryRemove(Handle, out var tmp);
}
else
{
response.Handle = Handle;
_lastActivity = DateTime.UtcNow;
}
return(response);
}
public CovidAppDeploymentMethodInvoker(IDeployMemoryQueueAdapter <CovidStatisticsAppDeploymentOption> deployMemoryQueueAdapter, IMethodHandler <CovidStatisticsAppDeploymentOption, MessageMethodResponse> methodHandler)
{
this.deployMemoryQueueAdapter = deployMemoryQueueAdapter;
this.methodHandler = methodHandler;
}
private void OnSOAProcess(object data)
{
object[] array = (object[])data;
IMethodHandler handler = (IMethodHandler)array[0];
ISession context = (ISession)array[1];
object[] message = (object[])array[2];
RemoteInvokeArgs riargs = (RemoteInvokeArgs)array[3];
RPC.MethodResult result = new RPC.MethodResult();
result.ID = riargs.CallID;
Implement.Session.Current = context;
result.Status = ResultStatus.Success;
MethodContext mc;
object rdata = null;
IList <Message> returnValues = new List <Message>();
returnValues.Add(new Message(result, typeof(RPC.MethodResult)));
IList <string> refParameters = null;
try
{
mc = new MethodContext(mApplication, context, message, handler);
mc.Execute();
rdata = mc.Result;
result.IsVoid = handler.Info.ReturnType == typeof(void);
if (!result.IsVoid)
{
returnValues.Add(new Message(rdata, handler.Info.ReturnType));
}
if (handler.Parameters.Length > 0)
{
result.Parameters = new string[handler.Parameters.Length];
for (int i = 0; i < handler.Parameters.Length; i++)
{
System.Reflection.ParameterInfo pi = handler.Parameters[i];
if (pi.IsOut || pi.IsRetval)
{
if (refParameters == null)
{
refParameters = new List <string>();
}
Type ptype = pi.ParameterType;
returnValues.Add(new Message(message[i], ptype.Name.IndexOf('&') == -1 ? ptype : ptype.GetElementType()));
refParameters.Add(pi.Name);
}
}
if (refParameters != null)
{
result.Parameters = refParameters.ToArray();
}
}
}
catch (Exception e_)
{
result.Status = ResultStatus.Error;
result.Error = e_.Message;
"{0} invoke error ".Log4Error(e_, handler.ToString());
context.Channel.InvokeError(e_);
}
finally
{
Implement.Session.Current = null;
}
try
{
Beetle.Express.IData sdata = ((IPacketAnalyzer)context.Channel.Package).GetMessageData(returnValues);
context.Application.Server.Send(sdata, context.Channel);
}
catch (Exception e__)
{
"{0} get return data error ".Log4Error(e__, handler.ToString());
context.Channel.InvokeError(e__);
}
}
