protected async Task ProcessCallbackCall(MessageEntry m)
{
MessageEntry ret = null;
try
{
ServiceStub s;
lock (stubs)
{
if (!stubs.ContainsKey(m.ServicePath))
{
throw new ServiceException("Stub not found");
}
s = stubs[m.ServicePath];
}
ret = await s.CallbackCall(m);
}
catch (Exception e)
{
ret = new MessageEntry(m.EntryType + 1, m.MemberName);
ret.ServicePath = m.ServicePath;
ret.RequestID = m.RequestID;
RobotRaconteurExceptionUtil.ExceptionToMessageEntry(e, ret);
}
await SendMessage(ret, default(CancellationToken));
}
public async Task <MessageEntry> ProcessRequest(MessageEntry m, CancellationToken cancel)
{
DateTime request_start = DateTime.UtcNow;
uint request_timeout = node.RequestTimeout;
TaskCompletionSource <MessageEntry> rec_source = new TaskCompletionSource <MessageEntry>();
uint t_id;
lock (rec_wait)
{
request_number++;
m.RequestID = request_number;
t_id = request_number;
rec_wait.Add(t_id, rec_source);
if (ProcessRequest_checkconnection_current == null)
{
ProcessRequest_checkconnection_current = ProcessRequest_checkconnection();
}
}
MessageEntry rec_message = null;
try
{
cancel.Register(delegate()
{
rec_source.TrySetCanceled();
});
Func <Task> r = async delegate()
{
await SendMessage(m, cancel);
rec_message = await rec_source.Task;
};
await r().AwaitWithTimeout((int)node.RequestTimeout);
}
finally
{
lock (rec_wait)
{
rec_wait.Remove(t_id);
}
}
if (rec_message.RequestID != t_id)
{
throw new Exception("This should be impossible!");
}
if (rec_message.Error != MessageErrorType.None)
{
Exception e = RobotRaconteurExceptionUtil.MessageEntryToException(rec_message);
RobotRaconteurRemoteException e2 = e as RobotRaconteurRemoteException;
if (e2 != null)
{
Exception e3 = ServiceDef.DownCastException(e2);
if (e3 != null)
{
e = e3;
}
}
throw e;
}
return(rec_message);
}
