public virtual async Task DispatchAsync(IEvent @event)
{
if (@event == null)
{
throw new ArgumentNullException(nameof(@event));
}
var eventType = @event.GetType();
var handlerTypes = _eventHandlerTypeStore.GetHandlerTypes(eventType);
foreach (var handlerType in handlerTypes)
{
var methodInfo = handlerType.GetMethod("HandleAsync");
if (methodInfo != null)
{
var handler = _handlerFactory.Create(handlerType);
if (handler != null)
{
if (methodInfo.Invoke(handler, new object[] { @event }) is Task task)
{
await task;
}
else
{
throw new ApplicationException($"Handle method is not async method");
}
}
else
{
throw new ApplicationException($"Create handler {handlerType} object failed");
}
}
}
}
protected override void InternalOnNext(Message value)
{
dynamic handler = handlerFactory.Create();
var se = new SearchableEvent()
{
Event = (IEvent)value.Payload,
AggregateId = value.Headers["ar_id"],
Revision = int.Parse(value.Headers["ar_revision"]),
Timestamp = DateTime.Parse(value.Headers["publish_timestamp"]),
EventPosition = int.Parse(value.Headers["event_position"]),
};
handler.Handle((dynamic)se);
}
protected async Task <DataWithStateCode> GenericHandle <T, TResult>(TRequest header, RequestContext <TRequest> context, CancellationToken token) where T : IOperation <TResult>
{
var segArray = header.OperationData.To();
var arg = context.OperationDescription.UseAsyncSerialize
? await _serializer.DeserializeAsync <T>(segArray, context.Session)
: _serializer.Deserialize <T>(segArray, context.Session);
var typedHandler = _factory.Create <T, TResult, TRequest>(context);
var result = await typedHandler.Handle(arg, context, token);
if (context.HandlerDescription.LifeTime == Scope.Request)
{
_factory.Destroy(typedHandler);
}
if (!context.OperationDescription.WaitResponse)
{
return(default);
public async Task <IHandler> Start()
{
var url = ParseUrl(_chaincodeSettings.PeerAddress);
// TODO: TLS Stuff?
var handler = _handlerFactory.Create(url.Host, url.Port);
var chaincodeId = new ChaincodeID {
Name = _chaincodeSettings.ChaincodeIdName
};
_logger.LogInformation("Registering with peer " +
$"{url.Host}:{url.Port} as chaincode " +
$"{_chaincodeSettings.ChaincodeIdName}");
await handler.Chat(new ChaincodeMessage
{
Type = ChaincodeMessage.Types.Type.Register,
Payload = chaincodeId.ToByteString()
});
return(handler);
}
public void Save(Type projectionType, IEvent @event, EventOrigin eventOrigin)
{
if (ReferenceEquals(null, projectionType))
{
throw new ArgumentNullException(nameof(projectionType));
}
if (ReferenceEquals(null, @event))
{
throw new ArgumentNullException(nameof(@event));
}
if (ReferenceEquals(null, eventOrigin))
{
throw new ArgumentNullException(nameof(eventOrigin));
}
string projectionName = projectionType.GetContractId();
var handlerInstance = handlerFactory.Create(projectionType);
var projection = handlerInstance.Current as IProjectionDefinition;
if (projection != null)
{
var projectionIds = projection.GetProjectionIds(@event);
foreach (var projectionId in projectionIds)
{
ReadResult <ProjectionVersions> result = GetProjectionVersions(projectionName);
if (result.IsSuccess)
{
foreach (ProjectionVersion version in result.Data)
{
if (version.Status == ProjectionStatus.Building || version.Status == ProjectionStatus.Live)
{
try
{
SnapshotMeta snapshotMeta = null;
if (projectionType.IsSnapshotable())
{
snapshotMeta = snapshotStore.LoadMeta(projectionName, projectionId, version);
}
else
{
snapshotMeta = new NoSnapshot(projectionId, projectionName).GetMeta();
}
ProjectionStream projectionStream = LoadProjectionStream(projectionType, version, projectionId, snapshotMeta);
int snapshotMarker = snapshotStrategy.GetSnapshotMarker(projectionStream.Commits, snapshotMeta.Revision);
var commit = new ProjectionCommit(projectionId, version, @event, snapshotMarker, eventOrigin, DateTime.UtcNow);
projectionStore.Save(commit);
}
catch (Exception ex)
{
log.ErrorException("Failed to persist event." + Environment.NewLine + $"\tProjectionVersion:{version}" + Environment.NewLine + $"\tEvent:{@event}", ex);
}
}
else if (version.Status == ProjectionStatus.NotPresent)
{
var commit = new ProjectionCommit(projectionId, version, @event, 1, eventOrigin, DateTime.UtcNow);
projectionStore.Save(commit);
}
}
}
}
}
}
private Task <TResult> SendCore <TRequest, TResult>(TRequest query) where TRequest : IRequest <TResult>
{
var handler = _handlerFactory.Create <IRequestHandler <TRequest, TResult> >();
return(handler.ExecuteAsync(query));
}
public object CreateRequestHandler <TResponse>(Type requestType)
{
var serviceType = typeof(IRequestHandler <,>).MakeGenericType(requestType, typeof(TResponse));
return(_handlerFactory.Create(serviceType));
}
public MessageHandlerMiddleware(IHandlerFactory factory)
{
CreateHandler = MiddlewareExtensions.Lambda <Type, IHandlerInstance>((execution) => factory.Create(execution.Context));
BeginHandle = MiddlewareExtensions.Lamda <HandlerContext>();
ActualHandle = new DynamicMessageHandle();
EndHandle = MiddlewareExtensions.Lamda <HandlerContext>();
Error = MiddlewareExtensions.Lamda <ErrorContext>();
Finalize = MiddlewareExtensions.Lamda <HandleContext>();
}
public async Task SaveAsync(Type projectionType, IEvent @event, EventOrigin eventOrigin)
{
if (ReferenceEquals(null, projectionType))
{
throw new ArgumentNullException(nameof(projectionType));
}
if (ReferenceEquals(null, @event))
{
throw new ArgumentNullException(nameof(@event));
}
if (ReferenceEquals(null, eventOrigin))
{
throw new ArgumentNullException(nameof(eventOrigin));
}
string projectionName = projectionType.GetContractId();
var handlerInstance = handlerFactory.Create(projectionType);
var projection = handlerInstance.Current as IProjectionDefinition;
if (projection != null)
{
var projectionIds = projection.GetProjectionIds(@event);
foreach (var projectionId in projectionIds)
{
using (log.BeginScope(s => s.AddScope("cronus_projection_id", projectionId)))
{
ReadResult <ProjectionVersions> result = await GetProjectionVersionsAsync(projectionName).ConfigureAwait(false);
if (result.IsSuccess)
{
foreach (ProjectionVersion version in result.Data)
{
using (log.BeginScope(s => s.AddScope("cronus_projection_version", version)))
{
if (ShouldSaveEventForVersion(version))
{
try
{
SnapshotMeta snapshotMeta = null;
if (projectionType.IsSnapshotable())
{
snapshotMeta = await snapshotStore.LoadMetaAsync(projectionName, projectionId, version).ConfigureAwait(false);
}
else
{
snapshotMeta = new NoSnapshot(projectionId, projectionName).GetMeta();
}
int snapshotMarker = snapshotMeta.Revision + 2;
var commit = new ProjectionCommit(projectionId, version, @event, snapshotMarker, eventOrigin, DateTime.UtcNow);
await projectionStore.SaveAsync(commit).ConfigureAwait(false);
}
catch (Exception ex) when(LogMessageWhenFailToUpdateProjection(ex, version))
{
}
}
}
}
if (result.HasError)
{
log.Error(() => "Failed to update projection because the projection version failed to load. Please replay the projection to restore the state. Self-heal hint!" + Environment.NewLine + result.Error + Environment.NewLine + $"\tProjectionName:{projectionName}" + Environment.NewLine + $"\tEvent:{@event}");
}
}
}
}
}
}
