public virtual async Task <(Result Result, TimeSpan Elapsed)> InvokeAsync(string actionName, string job)
{
var actionWatch = ValueStopwatch.StartNew();
Result result;
try
{
var actionType = typeNameRegistry.GetType(actionName);
var actionHandler = ruleActionHandlers[actionType];
var deserialized = jsonSerializer.Deserialize <object>(job, actionHandler.DataType);
using (var cts = new CancellationTokenSource(GetTimeoutInMs()))
{
result = await actionHandler.ExecuteJobAsync(deserialized, cts.Token).WithCancellation(cts.Token);
}
}
catch (Exception ex)
{
result = Result.Failed(ex);
}
var elapsed = TimeSpan.FromMilliseconds(actionWatch.Stop());
result.Enrich(elapsed);
return(result, elapsed);
}
public Envelope <IEvent> Parse(StoredEvent storedEvent)
{
Guard.NotNull(storedEvent, nameof(storedEvent));
var eventData = storedEvent.Data;
var payloadType = typeNameRegistry.GetType(eventData.Type);
var payloadValue = serializer.Deserialize <IEvent>(eventData.Payload, payloadType);
if (payloadValue is IMigrated <IEvent> migratedEvent)
{
payloadValue = migratedEvent.Migrate();
if (ReferenceEquals(migratedEvent, payloadValue))
{
Debug.WriteLine("Migration should return new event.");
}
}
var envelope = new Envelope <IEvent>(payloadValue, eventData.Headers);
envelope.SetEventPosition(storedEvent.EventPosition);
envelope.SetEventStreamNumber(storedEvent.EventStreamNumber);
return(envelope);
}
public virtual Envelope <IEvent> Parse(EventData eventData)
{
var headers = ReadJson <PropertiesBag>(eventData.Metadata);
var eventType = typeNameRegistry.GetType(eventData.Type);
var eventContent = ReadJson <IEvent>(eventData.Payload, eventType);
var envelope = new Envelope <IEvent>(eventContent, headers);
return(envelope);
}
public Envelope <IEvent> Parse(EventData eventData, Func <string, string> stringConverter = null)
{
var payloadType = typeNameRegistry.GetType(eventData.Type);
var payloadObj = serializer.Deserialize <IEvent>(eventData.Payload, payloadType, stringConverter);
if (payloadObj is IMigratedEvent migratedEvent)
{
payloadObj = migratedEvent.Migrate();
}
var envelope = new Envelope <IEvent>(payloadObj, eventData.Headers);
return(envelope);
}
public virtual Envelope <IEvent> Parse(EventData eventData, bool migrate = true)
{
var headers = ReadJson <PropertiesBag>(eventData.Metadata);
var eventType = typeNameRegistry.GetType(eventData.Type);
var eventPayload = ReadJson <IEvent>(eventData.Payload, eventType);
if (migrate && eventPayload is IMigratedEvent migratedEvent)
{
eventPayload = migratedEvent.Migrate();
}
var envelope = new Envelope <IEvent>(eventPayload, headers);
return(envelope);
}
public Envelope <IEvent> Parse(EventData eventData, bool migrate = true)
{
var eventType = typeNameRegistry.GetType(eventData.Type);
var headers = eventData.Metadata.ToObject <EnvelopeHeaders>();
var content = eventData.Payload.ToObject(eventType, serializer) as IEvent;
if (migrate && content is IMigratedEvent migratedEvent)
{
content = migratedEvent.Migrate();
}
var envelope = new Envelope <IEvent>(content, headers);
return(envelope);
}
public void Subscribe(string recipient, Action <object> handler)
{
Guard.NotNullOrEmpty(recipient, nameof(recipient));
pubSub.Subscribe(ChannelName, json =>
{
var envelope = JsonConvert.DeserializeObject <Envelope>(json);
if (string.Equals(envelope.Recipient, recipient, StringComparison.OrdinalIgnoreCase))
{
var messageType = typeNameRegistry.GetType(envelope.PayloadType);
var messageBody = ReadJson(envelope.Payload, messageType);
handler?.Invoke(messageBody);
}
});
}
public Envelope <IEvent> Parse(EventData eventData, bool migrate = true)
{
var headers = ReadJson <EnvelopeHeaders>(eventData.Metadata);
var eventType = typeNameRegistry.GetType(eventData.Type);
var eventPayload = ReadJson <IEvent>(eventData.Payload, eventType);
if (migrate && eventPayload is IMigratedEvent migratedEvent)
{
eventPayload = migratedEvent.Migrate();
}
var envelope = new Envelope <IEvent>(eventPayload, headers);
envelope.SetEventId(eventData.EventId);
return(envelope);
}
public Envelope <IEvent> Parse(EventData eventData, Func <string, string> stringConverter = null)
{
var payloadType = typeNameRegistry.GetType(eventData.Type);
var payloadObj = serializer.Deserialize <IEvent>(eventData.Payload, payloadType, stringConverter);
if (payloadObj is IMigrated <IEvent> migratedEvent)
{
payloadObj = migratedEvent.Migrate();
if (ReferenceEquals(migratedEvent, payloadObj))
{
Debug.WriteLine("Migration should return new event.");
}
}
var envelope = new Envelope <IEvent>(payloadObj, eventData.Headers);
return(envelope);
}
public virtual async Task <(string Dump, RuleResult Result, TimeSpan Elapsed)> InvokeAsync(string actionName, string job)
{
try
{
var actionType = typeNameRegistry.GetType(actionName);
var actionWatch = Stopwatch.StartNew();
var actionHandler = ruleActionHandlers[actionType];
var deserialized = jsonSerializer.Deserialize <object>(job, actionHandler.DataType);
var result = await actionHandler.ExecuteJobAsync(deserialized);
actionWatch.Stop();
var dumpBuilder = new StringBuilder(result.Dump);
dumpBuilder.AppendLine();
dumpBuilder.AppendFormat("Elapsed {0}.", actionWatch.Elapsed);
dumpBuilder.AppendLine();
if (result.Exception is TimeoutException || result.Exception is OperationCanceledException)
{
dumpBuilder.AppendLine();
dumpBuilder.AppendLine("Action timed out.");
return(dumpBuilder.ToString(), RuleResult.Timeout, actionWatch.Elapsed);
}
else if (result.Exception != null)
{
return(dumpBuilder.ToString(), RuleResult.Failed, actionWatch.Elapsed);
}
else
{
return(dumpBuilder.ToString(), RuleResult.Success, actionWatch.Elapsed);
}
}
catch (Exception ex)
{
return(ex.ToString(), RuleResult.Failed, TimeSpan.Zero);
}
}
public override Type BindToType(string assemblyName, string typeName)
{
var type = typeNameRegistry.GetType(typeName);
return(type ?? base.BindToType(assemblyName, typeName));
}
