protected override async ValueTask OnEventDelivered(IFullyEvent <long> fully)
{
switch (fully.Event)
{
case AmountTransferEvent value: await AmountAddEventHandler(value); break;
}
}
protected async ValueTask EventArchive(IFullyEvent <PrimaryKey> @event)
{
if (NewArchive == default)
{
NewArchive = new ArchiveBrief
{
Id = await ServiceProvider.GetService <IGrainFactory>().GetGrain <IUID>(GrainType.FullName).NewUtcID(),
StartTimestamp = @event.Base.Timestamp,
StartVersion = @event.Base.Version,
Index = LastArchive != default ? LastArchive.Index + 1 : 0,
EndTimestamp = @event.Base.Timestamp,
EndVersion = @event.Base.Version
};
}
else
{
//判定有没有时间戳小于前一个归档
if (NewArchive.StartTimestamp == 0 || @event.Base.Timestamp < NewArchive.StartTimestamp)
{
NewArchive.StartTimestamp = @event.Base.Timestamp;
}
if (@event.Base.Timestamp > NewArchive.StartTimestamp)
{
NewArchive.EndTimestamp = @event.Base.Timestamp;
}
NewArchive.EndVersion = @event.Base.Version;
}
var archiveTask = Archive();
if (!archiveTask.IsCompletedSuccessfully)
{
await archiveTask;
}
}
protected async ValueTask Tell(IFullyEvent <PrimaryKey> @event)
{
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace(LogEventIds.FollowEventProcessing, "Start event handling, grain Id = {0} and state version = {1},event type = {2} ,event = {3}", GrainId.ToString(), Snapshot.Version, @event.GetType().FullName, Serializer.SerializeToString(@event));
}
try
{
if (@event.Base.Version == Snapshot.Version + 1)
{
var onEventDeliveredTask = OnEventDelivered(@event);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.FullUpdateVersion(@event.Base, GrainType);//更新处理完成的Version
}
else if (@event.Base.Version > Snapshot.Version)
{
var eventList = await EventStorage.GetList(GrainId, Snapshot.StartTimestamp, Snapshot.Version + 1, @event.Base.Version - 1);
foreach (var evt in eventList)
{
var onEventDeliveredTask = OnEventDelivered(evt);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.FullUpdateVersion(evt.Base, GrainType);//更新处理完成的Version
}
}
if (@event.Base.Version == Snapshot.Version + 1)
{
var onEventDeliveredTask = OnEventDelivered(@event);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.FullUpdateVersion(@event.Base, GrainType);//更新处理完成的Version
}
if (@event.Base.Version > Snapshot.Version)
{
throw new EventVersionNotMatchStateException(GrainId.ToString(), GrainType, @event.Base.Version, Snapshot.Version);
}
await SaveSnapshotAsync();
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace(LogEventIds.FollowEventProcessing, "Event Handling Completion, grain Id ={0} and state version = {1},event type = {2}", GrainId.ToString(), Snapshot.Version, @event.GetType().FullName);
}
}
catch (Exception ex)
{
if (Logger.IsEnabled(LogLevel.Critical))
{
Logger.LogCritical(LogEventIds.FollowEventProcessing, ex, "FollowGrain Event handling failed with Id = {0},event = {1}", GrainId.ToString(), Serializer.SerializeToString(@event));
}
throw;
}
}
protected override async ValueTask OnEventDelivered(IFullyEvent <long> fully)
{
switch (fully.Event)
{
case AmountTransferEvent value: await AmountAddEventHandler(value, new EventUID(fully.GetEventId(), fully.Base.Timestamp)); break;
}
}
protected virtual ValueTask OnRaiseSuccessed(IFullyEvent <PrimaryKey> @event, EventBytesTransport bytesTransport)
{
if (ArchiveOptions.On)
{
return(EventArchive(@event));
}
return(Consts.ValueTaskDone);
}
protected virtual ValueTask OnRaiseFailed(IFullyEvent <PrimaryKey> @event)
{
if (ArchiveOptions.On && NewArchive != default)
{
return(Archive());
}
return(Consts.ValueTaskDone);
}
protected virtual ValueTask OnEventDelivered(IFullyEvent <PrimaryKey> @event)
{
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace("OnEventDelivered: {0}({1})", @event.GetType().FullName, Serializer.Serialize(@event, @event.GetType()));
}
SnapshotHandler.Apply(Snapshot, @event);
return(Consts.ValueTaskDone);
}
protected virtual ValueTask OnEventDelivered(IFullyEvent <PrimaryKey> @event)
{
if (SnapshotEventVersion > 0 && Snapshot.Version > 0 && @event.Base.Timestamp < Snapshot.StartTimestamp)
{
return(new ValueTask(ObserverSnapshotStorage.UpdateStartTimestamp(Snapshot.StateId, @event.Base.Timestamp)));
}
else
{
return(Consts.ValueTaskDone);
}
}
public override void CustomApply(Snapshot <long, AccountState> snapshot, IFullyEvent <long> fullyEvent)
{
switch (fullyEvent.Event)
{
case AmountAddEvent value: AmountAddEventHandle(snapshot.State, value); break;
case AmountTransferEvent value: AmountTransferEventHandle(snapshot.State, value); break;
default: break;
}
}
public void Apply(Snapshot <long, AccountState> state, IFullyEvent <long> fully)
{
switch (fully.Event)
{
case AmountAddEvent value: AmountAddEventHandle(state.State, value); break;
case AmountTransferEvent value: AmountTransferEventHandle(state.State, value); break;
default: break;
}
}
protected virtual ValueTask OnEventDelivered(IFullyEvent <PrimaryKey> @event)
{
try
{
SnapshotHandler.Apply(Snapshot, @event);
}
catch (Exception ex)
{
Logger.LogCritical(ex, "Delivered failed: {0}->{1}->{2}", GrainType.FullName, GrainId.ToString(), Serializer.Serialize(@event, @event.GetType()));
}
return(Consts.ValueTaskDone);
}
/// <summary>
/// 防止对象在State和BackupState中互相干扰，所以反序列化一个全新的Event对象给BackupState
/// </summary>
/// <param name="fullyEvent">事件本体</param>
/// <param name="bytes">事件序列化之后的二进制数据</param>
protected override ValueTask OnRaiseSuccessed(IFullyEvent <PrimaryKey> fullyEvent, EventBytesTransport bytesTransport)
{
var copiedEvent = new FullyEvent <PrimaryKey>
{
Event = Serializer.Deserialize(fullyEvent.Event.GetType(), bytesTransport.EventBytes) as IEvent,
Base = EventBase.FromBytes(bytesTransport.BaseBytes)
};
EventHandler.Apply(BackupSnapshot, copiedEvent);
BackupSnapshot.Base.FullUpdateVersion(copiedEvent.Base, GrainType);//更新处理完成的Version
//父级涉及状态归档
return(base.OnRaiseSuccessed(fullyEvent, bytesTransport));
}
public Task <bool> Append(IFullyEvent <PrimaryKey> fullyEvent, EventBytesTransport bytesTransport, string unique)
{
return(Task.Run(async() =>
{
var wrap = new AsyncInputEvent <BatchAppendTransport <PrimaryKey>, bool>(new BatchAppendTransport <PrimaryKey>(fullyEvent, bytesTransport, unique));
var writeTask = mpscChannel.WriteAsync(wrap);
if (!writeTask.IsCompletedSuccessfully)
{
await writeTask;
}
return await wrap.TaskSource.Task;
}));
}
protected virtual async ValueTask OnRaiseStart(IFullyEvent <PrimaryKey> @event)
{
if (Snapshot.Base.Version == 0)
{
return;
}
if (Snapshot.Base.IsLatest)
{
await SnapshotStorage.UpdateIsLatest(Snapshot.Base.StateId, false);
Snapshot.Base.IsLatest = false;
}
if (ClearedArchive != default && @event.Base.Timestamp < ClearedArchive.StartTimestamp)
{
throw new EventIsClearedException(@event.GetType().FullName, Serializer.SerializeToString(@event), ClearedArchive.Index);
}
if (SnapshotEventVersion > 0)
{
if (@event.Base.Timestamp < Snapshot.Base.LatestMinEventTimestamp)
{
await SnapshotStorage.UpdateLatestMinEventTimestamp(Snapshot.Base.StateId, @event.Base.Timestamp);
}
if (@event.Base.Timestamp < Snapshot.Base.StartTimestamp)
{
await SnapshotStorage.UpdateStartTimestamp(Snapshot.Base.StateId, @event.Base.Timestamp);
}
}
if (ArchiveOptions.On &&
LastArchive != default &&
@event.Base.Timestamp < LastArchive.EndTimestamp)
{
foreach (var archive in BriefArchiveList.Where(a => @event.Base.Timestamp < a.EndTimestamp && !a.EventIsCleared).OrderByDescending(v => v.Index))
{
if (@event.Base.Timestamp < archive.EndTimestamp)
{
await DeleteArchive(archive.Id);
if (NewArchive != default)
{
NewArchive = CombineArchiveInfo(archive, NewArchive);
}
else
{
NewArchive = archive;
}
BriefArchiveList.Remove(archive);
}
}
LastArchive = BriefArchiveList.LastOrDefault();
}
}
protected virtual async ValueTask EventDelivered(IFullyEvent <PrimaryKey> fullyEvent)
{
if (SnapshotEventVersion > 0 &&
Snapshot.Version > 0 &&
fullyEvent.Base.Timestamp < Snapshot.StartTimestamp)
{
await ObserverSnapshotStorage.UpdateStartTimestamp(Snapshot.StateId, fullyEvent.Base.Timestamp);
}
var task = OnEventDelivered(fullyEvent);
if (!task.IsCompletedSuccessfully)
{
await task;
}
}
protected async ValueTask Tell(IFullyEvent <PrimaryKey> @event)
{
try
{
if (@event.Base.Version == Snapshot.Base.Version + 1)
{
var onEventDeliveredTask = OnEventDelivered(@event);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.Base.FullUpdateVersion(@event.Base, GrainType);//更新处理完成的Version
}
else if (@event.Base.Version > Snapshot.Base.Version)
{
var eventList = await EventStorage.GetList(GrainId, Snapshot.Base.StartTimestamp, Snapshot.Base.Version + 1, @event.Base.Version - 1);
foreach (var evt in eventList)
{
var onEventDeliveredTask = OnEventDelivered(evt);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.Base.FullUpdateVersion(evt.Base, GrainType);//更新处理完成的Version
}
}
if (@event.Base.Version == Snapshot.Base.Version + 1)
{
var onEventDeliveredTask = OnEventDelivered(@event);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.Base.FullUpdateVersion(@event.Base, GrainType);//更新处理完成的Version
}
if (@event.Base.Version > Snapshot.Base.Version)
{
throw new EventVersionUnorderedException(GrainId.ToString(), GrainType, @event.Base.Version, Snapshot.Base.Version);
}
}
catch (Exception ex)
{
Logger.LogCritical(ex, "{0}({1})", @event.GetType().FullName, Serializer.Serialize(@event, @event.GetType()));
throw;
}
}
public virtual void Apply(Snapshot <PrimaryKey, Snapshot> snapshot, IFullyEvent <PrimaryKey> fullyEvent)
{
var eventType = fullyEvent.Event.GetType();
if (_handlerDict.TryGetValue(eventType, out var fun))
{
fun(snapshot.State, fullyEvent.Event);
}
else if (_handlerDict_1.TryGetValue(eventType, out var fun_1))
{
fun_1(snapshot.State, fullyEvent.Event, fullyEvent.Base);
}
else if (handlerAttribute == default || !handlerAttribute.Ignores.Contains(eventType))
{
throw new EventNotFoundHandlerException(eventType);
}
}
protected virtual ValueTask OnEventDelivered(IFullyEvent <PrimaryKey> fullyEvent)
{
var eventType = fullyEvent.Event.GetType();
if (_handlerDict_0.TryGetValue(eventType, out var func))
{
return(new ValueTask(func(this, fullyEvent.Event)));
}
else if (_handlerDict_1.TryGetValue(eventType, out var func_1))
{
return(new ValueTask(func_1(this, fullyEvent.Event, fullyEvent.Base)));
}
else if (handlerAttribute == default || !handlerAttribute.Ignores.Contains(eventType))
{
throw new EventNotFoundHandlerException(eventType);
}
return(Consts.ValueTaskDone);
}
protected override async ValueTask OnEventDelivered(IFullyEvent <K> @event)
{
var task = Process(@event);
if (!task.IsCompletedSuccessfully)
{
await task.AsTask().ContinueWith(t =>
{
if (t.Exception != null)
{
if (!(t.Exception.InnerException is Npgsql.PostgresException e && e.SqlState == "23505"))
{
ExceptionDispatchInfo.Capture(t.Exception).Throw();
}
}
});
}
}
public void Apply(Snapshot <PrimaryKey, Snapshot> snapshot, IFullyEvent <PrimaryKey> fullyEvent)
{
switch (fullyEvent.Event)
{
case TransactionFinishEvent _:
{
snapshot.Base.ClearTransactionInfo(false);
}; break;
case TransactionCommitEvent transactionCommitEvent:
{
snapshot.Base.TransactionStartVersion = transactionCommitEvent.StartVersion;
snapshot.Base.TransactionStartTimestamp = transactionCommitEvent.StartTimestamp;
snapshot.Base.TransactionId = transactionCommitEvent.Id;
}; break;
default: CustomApply(snapshot, fullyEvent); break;
}
}
protected override async ValueTask EventDelivered(IFullyEvent <K> @event)
{
var task = base.EventDelivered(@event);
if (!task.IsCompletedSuccessfully)
{
try
{
await task;
}
catch (Exception ex)
{
if (!(ex is Npgsql.PostgresException e && e.SqlState == "23505"))
{
throw;
}
}
}
}
protected override async ValueTask OnEventDelivered(IFullyEvent <K> @event)
{
var task = Process(@event);
if (!task.IsCompletedSuccessfully)
{
try
{
await task;
}
catch (Exception ex)
{
if (!(ex is Npgsql.PostgresException e && e.SqlState == "23505"))
{
ExceptionDispatchInfo.Capture(ex).Throw();
}
}
}
}
public override void Apply(Snapshot <PrimaryKey, Snapshot> snapshot, IFullyEvent <PrimaryKey> fullyEvent)
{
switch (fullyEvent.Event)
{
case TxFinishedEvent _:
{
if (snapshot.Base is TxSnapshotBase <PrimaryKey> snapshotBase)
{
snapshotBase.ClearTransactionInfo(false);
}
else
{
throw new SnapshotNotSupportTxException(snapshot.GetType());
}
}; break;
case TxCommitEvent transactionCommitEvent:
{
if (snapshot.Base is TxSnapshotBase <PrimaryKey> snapshotBase)
{
snapshotBase.TransactionStartVersion = transactionCommitEvent.StartVersion;
snapshotBase.TransactionStartTimestamp = transactionCommitEvent.StartTimestamp;
snapshotBase.TransactionId = transactionCommitEvent.Id;
}
else
{
throw new SnapshotNotSupportTxException(snapshot.GetType());
}
}; break;
default:
{
//如果产生非事务相关的事件，说明事务事件已被清理，应该执行一次清理动作
if (snapshot.Base is TxSnapshotBase <PrimaryKey> snapshotBase && snapshotBase.TransactionStartVersion != -1)
{
snapshotBase.ClearTransactionInfo(false);
}
CustomApply(snapshot, fullyEvent);
}; break;
}
}
protected async ValueTask Tell(IFullyEvent <PrimaryKey> @event)
{
if (@event.Base.Version == Snapshot.Base.Version + 1)
{
var onEventDeliveredTask = OnEventDelivered(@event);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.Base.FullUpdateVersion(@event.Base, GrainType);//更新处理完成的Version
}
else if (@event.Base.Version > Snapshot.Base.Version)
{
var eventList = await EventStorage.GetList(GrainId, Snapshot.Base.StartTimestamp, Snapshot.Base.Version + 1, @event.Base.Version - 1);
foreach (var evt in eventList)
{
var onEventDeliveredTask = OnEventDelivered(evt);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.Base.FullUpdateVersion(evt.Base, GrainType);//更新处理完成的Version
}
}
if (@event.Base.Version == Snapshot.Base.Version + 1)
{
var onEventDeliveredTask = OnEventDelivered(@event);
if (!onEventDeliveredTask.IsCompletedSuccessfully)
{
await onEventDeliveredTask;
}
Snapshot.Base.FullUpdateVersion(@event.Base, GrainType);//更新处理完成的Version
}
if (@event.Base.Version > Snapshot.Base.Version)
{
throw new EventVersionUnorderedException(GrainId.ToString(), GrainType, @event.Base.Version, Snapshot.Base.Version);
}
}
public virtual void CustomApply(Snapshot <PrimaryKey, Snapshot> snapshot, IFullyEvent <PrimaryKey> fullyEvent)
{
base.Apply(snapshot, fullyEvent);
}
protected virtual ValueTask OnEventDelivered(IFullyEvent <PrimaryKey> @event)
{
Snapshot.Apply(EventHandler, @event);
return(Consts.ValueTaskDone);
}
public static EventUID GetNextUID <K>(this IFullyEvent <K> @event)
{
return(new EventUID(@event.GetEventId(), @event.Base.Timestamp));
}
public static string GetEventId <K>(this IFullyEvent <K> @event)
{
return($"{@event.StateId.ToString()}_{@event.Base.Version.ToString()}");
}
public static void Apply <PrimaryKey, SnapshotType>(this Snapshot <PrimaryKey, SnapshotType> snapshot, IEventHandler <PrimaryKey, SnapshotType> handler, IFullyEvent <PrimaryKey> fullyEvent)
where SnapshotType : class, new()
{
switch (fullyEvent.Event)
{
case TransactionFinishEvent _:
{
snapshot.Base.ClearTransactionInfo(false);
}; break;
case TransactionCommitEvent transactionCommitEvent:
{
snapshot.Base.TransactionStartVersion = transactionCommitEvent.StartVersion;
snapshot.Base.TransactionStartTimestamp = transactionCommitEvent.StartTimestamp;
snapshot.Base.TransactionId = transactionCommitEvent.Id;
}; break;
default: handler.Apply(snapshot, fullyEvent); break;
}
}
public Task <bool> Append(IFullyEvent <PrimaryKey> fullyEvent, in EventBytesTransport bytesTransport, string unique)
