public PSEventResponseMessage(EventResponseMessage responseMessage)
{
Content = responseMessage?.Content;
Headers = responseMessage?.Headers;
ReasonPhrase = responseMessage?.ReasonPhrase;
StatusCode = responseMessage?.StatusCode;
Version = responseMessage?.Version;
}
public void ProcessOutbound(EventResponseMessage response)
{
var waiting = _queue.SingleOrDefault(self => self.Message.Id == response.Id) ??
throw new Exception($"No request matching {response.Id} was found.");
_queue.Remove(waiting);
waiting.Callback.Invoke(response.Data);
}
public async Task ProcessInboundAsync(EventMessage message, ISource source)
{
object InvokeDelegate(EventHandler subscription)
{
var parameters = new List <object>();
var @delegate = subscription.Delegate;
var method = @delegate.Method;
var takesSource = method.GetParameters().Any(self => self.ParameterType == source.GetType());
var startingIndex = takesSource ? 1 : 0;
if (takesSource)
{
parameters.Add(source);
}
if (message.Parameters == null)
{
return(@delegate.DynamicInvoke(parameters.ToArray()));
}
var array = message.Parameters.ToArray();
var holder = new List <object>();
var parameterInfos = @delegate.Method.GetParameters();
for (var index = 0; index < array.Length; index++)
{
var parameter = array[index];
var type = parameterInfos[startingIndex + index].ParameterType;
holder.Add(Serialization.Deserialize(type, parameter.Data));
}
parameters.AddRange(holder.ToArray());
return(@delegate.DynamicInvoke(parameters.ToArray()));
}
if (message.Flow == EventFlowType.Circle)
{
var stopwatch = StopwatchUtil.StartNew();
var subscription = _handlers.SingleOrDefault(self => self.Endpoint == message.Endpoint) ??
throw new Exception($"Could not find a handler for endpoint '{message.Endpoint}'");
var result = InvokeDelegate(subscription);
if (result?.GetType().GetGenericTypeDefinition() == typeof(Task <>))
{
using var token = new CancellationTokenSource();
var task = (Task)result;
var delay = Task.Run(async() => await DelayDelegate(30000), token.Token);
var completed = await Task.WhenAny(task, delay);
if (completed == task)
{
token.Cancel();
await task.ConfigureAwait(false);
result = (object)((dynamic)task).Result;
}
else
{
throw new TimeoutException(
$"({message.Endpoint} - {subscription.Delegate.Method.DeclaringType?.Name ?? "null"}/{subscription.Delegate.Method.Name}) The operation was timed out");
}
}
var response = new EventResponseMessage(message.Id, message.Signature, Serialization.Serialize(result));
var buffer = Serialization.Serialize(response);
PushDelegate(EventConstant.OutboundPipeline, source, buffer);
Logger.Debug(
$"[{message.Endpoint}] Responded to {source} with {buffer.Length} byte(s) in {stopwatch.Elapsed.TotalMilliseconds}ms");
}
else
{
foreach (var handler in _handlers.Where(self => message.Endpoint == self.Endpoint))
{
InvokeDelegate(handler);
}
}
}
