protected override void SetUpPerTest(QueueStorage storage, EventStorage eventStorage)
{
using (var sqlConnection = new SqlConnection(ConnectionString))
{
sqlConnection.Open();
using (var cmd = new SqlCommand("truncate table Events;", sqlConnection))
{
cmd.ExecuteNonQuery();
}
using (var cmd = new SqlCommand("truncate table Streams;", sqlConnection))
{
cmd.ExecuteNonQuery();
}
using (var cmd = new SqlCommand("truncate table QueueAllocations;", sqlConnection))
{
cmd.ExecuteNonQuery();
}
using (var cmd = new SqlCommand("truncate table Queues;", sqlConnection))
{
cmd.ExecuteNonQuery();
}
}
}
public EventListenerBackgroundService(
EventStorage eventStorage,
ISlackEventIdentifier slackEventIdentifier)
{
_eventStorage = eventStorage;
_slackEventIdentifier = slackEventIdentifier;
}
protected async Task <bool> RaiseEvent(IEventBase <K> @event, string uniqueId = null, string mqHashKey = null)
{
try
{
@event.StateId = GrainId;
@event.Version = this.State.Version + 1;
@event.Timestamp = DateTime.Now;
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, @event);
var bytes = ms.ToArray();
var result = await EventStorage.InsertAsync(@event, bytes, uniqueId, SendEventToMQ);
if (result)
{
@event.Apply(this.State);
await EventInsertAfterHandle(@event, bytes, mqHashKey : mqHashKey);
RaiseEventAfter(@event, bytes);
return(true);
}
}
}
catch (Exception ex)
{
this.GetLogger("Event_Raise").Log(LogCodes.EventRaiseError, Orleans.Runtime.Severity.Error, $"applay event {@event.TypeCode} error, eventId={@event.Version}", null, ex);
throw ex;
}
return(false);
}
public void SetUp()
{
_eventStorage = GetEventStorage();
_queueStorage = GetQueueStorage();
SetUpPerTest(_queueStorage, _eventStorage);
}
// Use this for initialization
void Start()
{
_eventStorage = EventStorage.Instance;
_eventStorage.ConnectionEstablished.AddListener(_startWeatherUpdate);
_eventStorage.ConnectionTerminated.AddListener(_stopWeatherUpdate);
Debug.Log("Weather subscribed.");
}
private async Task EventInsertAfterHandle(IEventBase <K> @event, byte[] bytes, int recursion = 0, string mqHashKey = null)
{
try
{
if (SendEventToMQ)
{
if (string.IsNullOrEmpty(mqHashKey))
{
mqHashKey = GrainId.ToString();
}
//消息写入消息队列
await MQService.Send(@event, bytes, mqHashKey);
}
//更改消息状态
await EventStorage.Complete(@event);
//保存快照
await SaveSnapshotAsync();
}
catch (Exception e)
{
if (recursion > 5)
{
throw e;
}
this.GetLogger("Event_Raise").Log(LogCodes.EventCompleteError, Orleans.Runtime.Severity.Error, "事件complate操作出现致命异常:" + string.Format("Grain类型={0},GrainId={1},StateId={2},Version={3},错误信息:{4}", ThisType.FullName, GrainId, @event.StateId, @event.Version, e.Message), null, e);
int newRecursion = recursion + 1;
await Task.Delay(newRecursion * 200);
await EventInsertAfterHandle(@event, bytes, newRecursion, mqHashKey : mqHashKey);
}
}
protected override async ValueTask OnFinshTransaction(long transactionId)
{
if (transactionId > 0)
{
if (!TransactionOptions.RetainTxEvents)
{
if (Snapshot.Base is TxSnapshotBase <PrimaryKey> snapshotBase &&
BackupSnapshot.Base is TxSnapshotBase <PrimaryKey> backupSnapshotBase)
{
//删除最后一个TransactionCommitEvent
await EventStorage.DeleteByVersion(Snapshot.Base.StateId, snapshotBase.TransactionStartVersion, snapshotBase.TransactionStartTimestamp);
var txCommitEvent = WaitingForTransactionTransports.Single(o => o.FullyEvent.Base.Version == snapshotBase.TransactionStartVersion);
WaitingForTransactionTransports.Remove(txCommitEvent);
snapshotBase.ClearTransactionInfo(true);
backupSnapshotBase.ClearTransactionInfo(true);
}
else
{
throw new SnapshotNotSupportTxException(Snapshot.GetType());
}
}
else
{
await base.RaiseEvent(new TxFinishedEvent(transactionId));
}
}
}
public Standard(EventStorage _events, Config _config, CommandService _commands, IServiceProvider _services)
{
events = _events;
config = _config;
commands = _commands;
services = _services;
}
protected override async ValueTask OnFinshTransaction(long transactionId)
{
if (transactionId > 0)
{
if (!TransactionOptions.RetainTxEvents)
{
//删除最后一个TransactionCommitEvent
await EventStorage.DeleteEnd(Snapshot.Base.StateId, Snapshot.Base.Version, Snapshot.Base.LatestMinEventTimestamp);
if (Snapshot.Base is TxSnapshotBase <PrimaryKey> snapshotBase &&
BackupSnapshot.Base is TxSnapshotBase <PrimaryKey> backupSnapshotBase)
{
snapshotBase.ClearTransactionInfo(true);
backupSnapshotBase.ClearTransactionInfo(true);
}
else
{
throw new SnapshotNotSupportTxException(Snapshot.GetType());
}
}
else
{
await base.RaiseEvent(new TxFinishedEvent(transactionId));
}
}
}
protected async ValueTask<bool> RaiseEvent(IEventBase<K> @event, string uniqueId = null, string hashKey = null)
{
try
{
this.State.IncrementDoingVersion();//标记将要处理的Version
@event.StateId = GrainId;
@event.Version = this.State.Version + 1;
@event.Timestamp = DateTime.UtcNow;
using (var ms = new PooledMemoryStream())
{
Serializer.Serialize(ms, @event);
var bytes = ms.ToArray();
var result = await EventStorage.SaveAsync(@event, bytes, uniqueId);
if (result)
{
EventHandle.Apply(this.State, @event);
await AfterEventSavedHandle(@event, bytes, hashKey: hashKey);
this.State.UpdateVersion(@event);//更新处理完成的Version
await SaveSnapshotAsync();
return true;
}
else
this.State.DecrementDoingVersion();//还原doing Version
}
}
catch (Exception ex)
{
this.GetLogger("Event_Raise").Log(LogCodes.EventRaiseError, Orleans.Runtime.Severity.Error, $"applay event {@event.TypeCode} error, eventId={@event.Version}", null, ex);
await OnActivateAsync();//重新激活Actor
throw ex;
}
return false;
}
protected virtual async Task AfterEventSavedHandle(IEventBase <K> @event, byte[] bytes, int recursion = 0, string hashKey = null)
{
try
{
if (string.IsNullOrEmpty(hashKey))
{
hashKey = GrainId.ToString();
}
//消息写入消息队列
await MQService.Publish(@event, bytes, hashKey);
//更改消息状态
await EventStorage.CompleteAsync(@event);
}
catch (Exception e)
{
if (recursion > 5)
{
throw e;
}
this.GetLogger("Event_Raise").Log(LogCodes.EventCompleteError, Orleans.Runtime.Severity.Error, "事件complate操作出现致命异常:" + string.Format("Grain类型={0},GrainId={1},StateId={2},Version={3},错误信息:{4}", ThisType.FullName, GrainId, @event.StateId, @event.Version, e.Message), null, e);
int newRecursion = recursion + 1;
await Task.Delay(newRecursion * 200);
await AfterEventSavedHandle(@event, bytes, newRecursion, hashKey : hashKey);
}
}
public override async Task OnActivateAsync()
{
await ReadSnapshotAsync();
while (true)
{
var eventList = await EventStorage.GetListAsync(this.GrainId, this.State.Version, this.State.Version + 1000, this.State.VersionTime);
foreach (var @event in eventList)
{
this.State.IncrementDoingVersion();//标记将要处理的Version
EventHandle.Apply(this.State, @event.Event);
if ([email protected])
{
using (var ms = new PooledMemoryStream())
{
Serializer.Serialize(ms, @event.Event);
await AfterEventSavedHandle(@event.Event, ms.ToArray());
}
}
this.State.UpdateVersion(@event.Event);//更新处理完成的Version
}
if (eventList.Count < 1000)
{
break;
}
}
;
}
public void Repository_Get()
{
//Arrange
var id = Guid.NewGuid();
EventStorage.Get(id, -1, "employees")
.Returns(
new List <Event>()
{
new EmployeeCreatedEvent(55, "Alejandro", "Molines", new DateTime(1981, 11, 28), "Developer")
}
);
//Act
var user = _eventRepository.Get <Employee>(id).Result;
//Assert
user.EmployeeId.Should().Be(55);
user.FirstName.Should().Be("Alejandro");
user.LastName.Should().Be("Molines");
user.JobTitle.Should().Be("Developer");
user.DateOfBirth.Should().Be(28.November(1981));
EventStorage.Received(1).Get(id, -1, "employees");
}
public EventStorageWriter(int maxSize, TimeSpan maxAgeBeforeDrop, EventStorage storage, int maxBatchSize = 2048)
{
_maxSize = maxSize;
_maxAgeBeforeDrop = maxAgeBeforeDrop;
_storage = storage;
_maxBatchSize = maxBatchSize;
}
public override async Task OnActivateAsync()
{
await base.OnActivateAsync();
//如果失活之前已提交事务还没有Complete,则消耗信号量，防止产生新的事物
if (Snapshot.Base.TransactionId != 0)
{
await TransactionSemaphore.WaitAsync();
var waitingEvents = await EventStorage.GetList(GrainId, Snapshot.Base.TransactionStartTimestamp, Snapshot.Base.TransactionStartVersion, Snapshot.Base.Version);
foreach (var evt in waitingEvents)
{
WaitingForTransactionTransports.Add(new EventTransport <PrimaryKey>(evt, string.Empty, evt.StateId.ToString())
{
BytesTransport = new EventBytesTransport
{
EventType = evt.Event.GetType().FullName,
GrainId = GrainId,
EventBytes = Serializer.SerializeToBytes(evt.Event),
BaseBytes = evt.Base.GetBytes()
}
});
}
CurrentTransactionId = Snapshot.Base.TransactionId;
CurrentTransactionStartVersion = Snapshot.Base.TransactionStartVersion;
}
}
/// <summary>
/// 异步发布事件，储存事件
/// </summary>
/// <typeparam name="TAggregationRoot"></typeparam>
/// <param name="event"></param>
/// <returns></returns>
public async Task PublishEventAsync <TAggregationRoot>(TAggregationRoot @event) where TAggregationRoot : IAggregationRoot
{
var domainEventList = @event.UncommittedEvents.ToList();
TryDapperConnection();
using (var transaction = _connection.BeginTransaction())
{
if (domainEventList.Count > 0)
{
foreach (var domainEvent in domainEventList)
{
EventStorage eventStorage = new EventStorage
{
Id = domainEvent.Id,
AggregateRootId = domainEvent.AggregateRootId,
AggregateRootType = domainEvent.AggregateRootType,
CreateDateTime = domainEvent.CreateDateTime,
Version = domainEvent.Version,
EventData = JsonConvert.SerializeObject(domainEvent)
};
var eventStorageSql = $"INSERT INTO EventStorageInfo(Id,AggregateRootId,AggregateRootType,CreateDateTime,Version,EventData) VALUES (@Id,@AggregateRootId,@AggregateRootType,@CreateDateTime,@Version,@EventData)";
await _connection.ExecuteAsync(eventStorageSql, eventStorage, transaction);
await _capPublisher.PublishAsync(domainEvent.GetRoutingKey(), domainEvent);
}
}
transaction.Commit();
_connection.Close();
@event.ClearEvents();
}
}
public override async Task OnActivateAsync()
{
await ReadSnapshotAsync();
while (true)
{
var eventList = await EventStorage.GetListAsync(this.GrainId, this.State.Version, this.State.Version + 1000, this.State.VersionTime);
foreach (var @event in eventList)
{
@event.Event.Apply(this.State);
if ([email protected])
{
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, @event.Event);
await EventInsertAfterHandle(@event.Event, ms.ToArray());
}
}
}
if (eventList.Count < 1000)
{
break;
}
}
;
}
void Start()
{
_eventStorage = EventStorage.Instance;
_eventStorage.UserLocationDetermined.AddListener(_pleaseWork);
_eventStorage.LocationClicked.AddListener(_show);
_eventStorage.MapToDefault.AddListener(_hide);
}
internal static void setEnabled(Boolean enabled)
{
if (enabled && !isEnabled)
{
//Read events from storage
eventsList = EventStorage.getEvents();
if (eventsList.Count > 0)
{
sendNextEvent();
}
isEnabled = true;
}
else if (!enabled && isEnabled)
{
//Stop current eventSender
if (eventSender != null)
{
eventSender.cancel();
eventSender = null;
}
//Store events to storage
EventStorage.storeEvents(eventsList);
eventsList = null;
isEnabled = false;
}
}
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;
}
}
public override async Task OnActivateAsync()
{
await base.OnActivateAsync();
//如果失活之前已提交事务还没有Complete,则消耗信号量，防止产生新的事物
if (Snapshot.Base is TxSnapshotBase <PrimaryKey> snapshotBase)
{
if (snapshotBase.TransactionId != 0)
{
await TransactionSemaphore.WaitAsync();
var waitingEvents = await EventStorage.GetList(GrainId, snapshotBase.TransactionStartTimestamp, snapshotBase.TransactionStartVersion, Snapshot.Base.Version);
foreach (var evt in waitingEvents)
{
var evtType = evt.Event.GetType();
WaitingForTransactionTransports.Add(new EventTransport <PrimaryKey>(evt, string.Empty, evt.StateId.ToString())
{
BytesTransport = new EventBytesTransport(
TypeContainer.GetTypeCode(evtType),
GrainId,
evt.Base.GetBytes(),
Serializer.SerializeToUtf8Bytes(evt.Event, evtType)
)
});
}
CurrentTransactionId = snapshotBase.TransactionId;
CurrentTransactionStartVersion = snapshotBase.TransactionStartVersion;
}
}
else
{
throw new SnapshotNotSupportTxException(Snapshot.GetType());
}
}
private void CommandConfiguration()
{
Commands = new List <SessionCommand>
{
new BaseCommand("Name", new TextResponse($"Set event name{Emoji.Pointer}", ResponseStatus.Expect), r =>
{
Event.SetName(r.Command);
return(new TextResponse(Emoji.CheckMark, ResponseStatus.Close));
}),
new BaseCommand("Description", new TextResponse($"Set event description{Emoji.Pointer}", ResponseStatus.Expect), r =>
{
Event.SetDescription(r.Command);
return(new TextResponse(Emoji.CheckMark, ResponseStatus.Close));
}),
new SetDateTimeCommand("Start time", d => Event.SetStaringTime(d)),
new SetDateTimeCommand("End time", d => Event.SetEndingTime(d)),
new SetTimeSpanCommand("First Reminder", span => Event.SetFirstReminder(span)),
new SetTimeSpanCommand("Second Reminder", span => Event.SetSecondReminder(span)),
new BaseCommand("Exit", null, r =>
{
Event = null;
return(new TextResponse("Exit", ResponseStatus.Abort));
}, false),
new BaseCommand("Save", null, r =>
{
if (Event.Name == null || Name.Length == 0)
{
return(new TextResponse(Emoji.CrossMark + "Add event name", ResponseStatus.Exception));
}
EventStorage.Add(Event);
return(new TextResponse(Emoji.CheckMark, ResponseStatus.Abort));
}, false)
}.ToDictionary(x => x.Name, x => x);
}
void Start()
{
Canvas.ForceUpdateCanvases();
_initializeFirst();
_eventStorage = EventStorage.Instance;
_eventStorage.LocationClicked.AddListener(_switchToNavigation);
}
// Use this for initialization
void Start()
{
#if UNITY_ANDROID || UNITY_IPHONE
_eventStorage = EventStorage.Instance;
_eventStorage.ConnectionEstablished.AddListener(_startGeolocation);
_eventStorage.ConnectionTerminated.AddListener(_stopGeolocation);
#endif
}
// Use this for initialization
void Start()
{
_eventStorage = EventStorage.Instance;
_downloadAndInitializeEvents();
_startEventPointerUpdate();
}
private Plugin()
{
Icons = new Dictionary <string, Image>();
ItemTemplates = new List <ItemTemplate>();
ProjectTemplates = new List <ProjectTemplate>();
Dependencies = new List <Library>();
Events = new EventStorage();
Windows = new WindowCollection();
}
private Plugin()
{
Icons = new Dictionary<string, Image>();
ItemTemplates = new List<ItemTemplate>();
ProjectTemplates = new List<ProjectTemplate>();
Dependencies = new List<Library>();
Events = new EventStorage();
Windows = new WindowCollection();
}
void Start()
{
_notificator = UserNotificator.Instance;
_eventStorage = EventStorage.Instance;
_eventStorage.DropUserLoc.AddListener(_dropUserLocation);
_eventStorage.LocationClicked.AddListener(_centralizeAt);
_eventStorage.MapToDefault.AddListener(_dropCenterAndRefresh);
_eventStorage.UserLocationDetermined.AddListener(_addUserLocationMarkerAndRefresh);
_eventStorage.MapToUser.AddListener(_centerToUserAndRefresh);
_eventStorage.OpenMaps.AddListener(_openGoogleMapsWithCurrentCenter);
_initialize();
}
protected virtual async ValueTask OnArchiveCompleted()
{
//开始执行事件清理逻辑
var noCleareds = BriefArchiveList.Where(a => !a.EventIsCleared).ToList();
if (noCleareds.Count >= ArchiveOptions.MaxSnapshotArchiveRecords)
{
var minArchive = noCleareds.FirstOrDefault();
if (minArchive != default)
{
//判断需要清理的event是否都被follow执行过
var versions = await Task.WhenAll(FollowUnit.GetAndSaveVersionFuncs().Select(func => func(Snapshot.Base.StateId, Snapshot.Base.Version)));
if (versions.All(v => v >= minArchive.EndVersion))
{
//清理归档对应的事件
await ArchiveStorage.EventIsClear(Snapshot.Base.StateId, minArchive.Id);
minArchive.EventIsCleared = true;
//如果快照的版本小于需要清理的最大事件版本号，则保存快照
if (SnapshotEventVersion < minArchive.EndVersion)
{
var saveTask = SaveSnapshotAsync(true);
if (!saveTask.IsCompletedSuccessfully)
{
await saveTask;
}
}
if (ArchiveOptions.DeleteEvents)
{
await EventStorage.DeleteStart(Snapshot.Base.StateId, minArchive.EndVersion, Snapshot.Base.StartTimestamp);
}
else
{
await ArchiveStorage.EventArichive(Snapshot.Base.StateId, minArchive.EndVersion, Snapshot.Base.StartTimestamp);
}
ClearedArchive = minArchive;
//只保留一个清理过事件的快照，其它的删除掉
var cleareds = BriefArchiveList.Where(a => a.EventIsCleared).OrderBy(a => a.Index).ToArray();
if (cleareds.Length > 1)
{
for (int i = 0; i < cleareds.Length - 1; i++)
{
await DeleteArchive(cleareds[i].Id);
BriefArchiveList.Remove(cleareds[i]);
}
}
}
}
}
}
public IEventRepository CreateEventRepository(IShardCalculator shardCalculator, IEventRepositoryColumnFamilyFullNames columnFamilies, IEventLogProfiler profiler, TimeSpan eventsTtl)
{
var eventLogPointerCreator = new EventLogPointerCreator();
var remoteLockImplementation = new CassandraRemoteLockImplementation(cassandraCluster, serializer, CassandraRemoteLockImplementationSettings.Default(columnFamilies.RemoteLock.KeyspaceName, columnFamilies.RemoteLock.ColumnFamilyName));
var remoteLocker = new RemoteLocker(remoteLockImplementation, new RemoteLockerMetrics(columnFamilies.RemoteLock.KeyspaceName), logger);
var eventLoggerAdditionalInfoRepository = new EventLoggerAdditionalInfoRepository(cassandraCluster, serializer, remoteLocker, columnFamilies.EventLogAdditionalInfo, columnFamilies.EventLog);
var eventStorage = new EventStorage(columnFamilies.EventLog, eventLogPointerCreator, cassandraCluster, serializer);
Func <IQueueRaker> createQueueRaker = () => new QueueRaker(eventStorage, eventLoggerAdditionalInfoRepository, profiler, logger, eventsTtl);
var eventLogger = new EventLogger(cassandraCluster, serializer, columnFamilies.EventLog, eventLogPointerCreator, createQueueRaker, eventLoggerAdditionalInfoRepository, profiler, logger);
return(new EventRepository(eventTypeIdentifierProvider, eventLogger, shardCalculator, serializer));
}
protected async Task Over()
{
if (Snapshot.Base.IsOver)
{
throw new StateIsOverException(Snapshot.Base.StateId.ToString(), GrainType);
}
if (Snapshot.Base.Version != Snapshot.Base.DoingVersion)
{
throw new StateInsecurityException(Snapshot.Base.StateId.ToString(), GrainType, Snapshot.Base.DoingVersion, Snapshot.Base.Version);
}
if (ArchiveOptions.On && ArchiveOptions.ArchiveEventOnOver)
{
var versions = await ObserverUnit.GetAndSaveVersion(Snapshot.Base.StateId, Snapshot.Base.Version);
if (versions.Any(v => v < Snapshot.Base.Version))
{
throw new ObserverNotCompletedException(GrainType.FullName, Snapshot.Base.StateId.ToString());
}
}
Snapshot.Base.IsOver = true;
Snapshot.Base.IsLatest = true;
if (SnapshotEventVersion != Snapshot.Base.Version)
{
var saveTask = SaveSnapshotAsync(true, true);
if (!saveTask.IsCompletedSuccessfully)
{
await saveTask;
}
}
else
{
await SnapshotStorage.Over(Snapshot.Base.StateId, true);
}
if (ArchiveOptions.On && ArchiveOptions.ArchiveEventOnOver)
{
await ArchiveStorage.DeleteAll(Snapshot.Base.StateId);
if (ArchiveOptions.EventArchiveType == EventArchiveType.Delete)
{
await EventStorage.DeleteStart(Snapshot.Base.StateId, Snapshot.Base.Version, Snapshot.Base.StartTimestamp);
}
else
{
await ArchiveStorage.EventArichive(Snapshot.Base.StateId, Snapshot.Base.Version, Snapshot.Base.StartTimestamp);
}
}
else
{
await ArchiveStorage.Over(Snapshot.Base.StateId, true);
}
}
public async Task Tell(W message)
{
var type = MessageTypeMapping.GetType(message.TypeCode);
if (type != null)
{
using (var ems = new MemoryStream(message.BinaryBytes))
{
var @event = Serializer.Deserialize(type, ems) as IEventBase<K>;
if (@event != null)
{
if (@event.Version == this.State.Version + 1)
{
await OnExecution(@event);
this.State.IncrementDoingVersion();//标记将要处理的Version
EventHandle.Apply(this.State, @event);
this.State.UpdateVersion(@event);//更新处理完成的Version
await OnExecuted(@event);
await SaveSnapshotAsync();
}
else if (@event.Version > this.State.Version)
{
var eventList = await EventStorage.GetListAsync(this.GrainId, this.State.Version, @event.Version);
foreach (var item in eventList)
{
await OnExecution(@event);
this.State.IncrementDoingVersion();//标记将要处理的Version
EventHandle.Apply(this.State, @event);
this.State.UpdateVersion(@event);//更新处理完成的Version
await OnExecuted(@event);
await SaveSnapshotAsync();
}
}
if (@event.Version == this.State.Version + 1)
{
await OnExecution(@event);
this.State.IncrementDoingVersion();//标记将要处理的Version
EventHandle.Apply(this.State, @event);
this.State.UpdateVersion(@event);//更新处理完成的Version
await OnExecuted(@event);
await SaveSnapshotAsync();
}
if (@event.Version > this.State.Version)
{
throw new Exception($"Event version of the error,Type={ThisType.FullName},StateId={this.GrainId.ToString()},StateVersion={this.State.Version},EventVersion={@event.Version}");
}
}
}
}
}
private async Task FullActive()
{
while (true)
{
var eventList = await EventStorage.GetList(GrainId, Snapshot.StartTimestamp, Snapshot.Version + 1, Snapshot.Version + ConfigOptions.NumberOfEventsPerRead);
if (EventConcurrentProcessing)
{
await Task.WhenAll(eventList.Select(@event =>
{
var task = OnEventDelivered(@event);
if (!task.IsCompletedSuccessfully)
{
return(task.AsTask());
}
else
{
return(Task.CompletedTask);
}
}));
var lastEvt = eventList.Last();
Snapshot.UnsafeUpdateVersion(lastEvt.Base);
}
else
{
foreach (var @event in eventList)
{
Snapshot.IncrementDoingVersion(GrainType);//标记将要处理的Version
var task = OnEventDelivered(@event);
if (!task.IsCompletedSuccessfully)
{
await task;
}
Snapshot.UpdateVersion(@event.Base, GrainType);//更新处理完成的Version
}
}
var saveTask = SaveSnapshotAsync();
if (!saveTask.IsCompletedSuccessfully)
{
await saveTask;
}
if (eventList.Count < ConfigOptions.NumberOfEventsPerRead)
{
break;
}
}
;
}
public ConcurrentEventStore(EventStorage storage, IEnumerable<EventSet> preload, Action<int> notifier_target, Func<object, string> discriminator_factory)
{
_storage = storage;
_discriminatorFactory = discriminator_factory;
Refresh();
_notifierTarget = notifier_target ?? (_ => { });
_streamversions =
storage.All.SelectMany(_ => _.Envelopes)
.GroupBy(_ => _.Header.Stream)
.Select(_ => new {Stream = _.Key, Version = _.Max(a => a.Header.StreamVersion)})
.ToDictionary(_ => _.Stream, _ => _.Version);
Preload(preload ?? new List<EventSet>());
}
public EventStorageTest()
{
var fake = new Faker();
_eventDto = new EventDto
{
Name = fake.Random.Words(),
Description = fake.Lorem.Paragraph(),
StartDate = fake.Date.Recent().ToString(),
FinishDate = fake.Date.Recent().ToString()
};
_eventRepositoryMock = new Mock <IEventRepository>();
_eventStorage = new EventStorage(_eventRepositoryMock.Object);
}
protected virtual void SetUpPerTest(EventStorage storage)
{
}
private QueueStorage getQueueStorage(string connectionStringName, EventStorage eventStorage)
{
if (connectionStringName == "inmem")
{
if (eventStorage is InMemoryEventStorage == false)
throw new ArgumentException(
"In memory queue storage can't be used without in memory event storage.", "eventStorage");
return new InMemoryQueueStorage((InMemoryEventStorage) eventStorage);
}
else
{
var connectionString = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
var queueStorage = new SqlQueueStorage(connectionString);
return queueStorage;
}
}
public ConcurrentEventStore(EventStorage storage, IEnumerable<EventSet> preload)
: this(storage, preload, null)
{
}
public ConcurrentEventStore(EventStorage storage)
: this(storage, null, null)
{
}
public SinglethreadEventStore(EventStorage storage)
: this(storage, null, null)
{
}
protected virtual void TearDownPerTest(EventStorage storage)
{
}
private static void Main(string[] args)
{
var eventStorage = new EventStorage();
var query = new BookStateQuery();
DomainEvents.RegisterHandler(() => new BookStateHandler(query));
DomainEvents.RegisterHandler(() => new LateReturnNotifier());
var bookId = BookId.NewBookId();
using (var session = new Session(eventStorage))
{
var books = new BookRepository();
var book = new Book(bookId,
"The Lord of the Rings",
"0-618-15396-9");
books.Add(book);
session.SubmitChanges();
}
ShowBooks(query);
using (var session = new Session(eventStorage))
{
var books = new BookRepository();
var book = books[bookId];
book.Lend("Alice",
new DateTime(2009, 11, 2),
TimeSpan.FromDays(14));
session.SubmitChanges();
}
ShowBooks(query);
using (var session = new Session(eventStorage))
{
var books = new BookRepository();
var book = books[bookId];
book.Return(new DateTime(2009, 11, 8));
session.SubmitChanges();
}
ShowBooks(query);
using (var session = new Session(eventStorage))
{
var books = new BookRepository();
var book = books[bookId];
book.Lend("Bob",
new DateTime(2009, 11, 9),
TimeSpan.FromDays(14));
session.SubmitChanges();
}
ShowBooks(query);
using (var session = new Session(eventStorage))
{
var books = new BookRepository();
var book = books[bookId];
book.Return(new DateTime(2010, 03, 1));
session.SubmitChanges();
}
ShowBooks(query);
}
public SinglethreadEventStore(EventStorage storage, Action<int> notifier_target)
: this(storage, null, notifier_target)
{
}
public void PerTestSetup()
{
_storage = GetStorage();
SetUpPerTest(_storage);
}
/// <summary>
/// Helper function to get all of the event handlers for the Freezable and
/// place them in the calledHandlers list.
/// <param name="calledHandlers"> Where to place the change handlers for the Freezable. </param>
/// </summary>
private void GetHandlers(ref EventStorage calledHandlers)
{
if (Freezable_UsingSingletonHandler)
{
if (calledHandlers == null)
{
calledHandlers = GetEventStorage();
}
calledHandlers.Add(SingletonHandler);
}
else if (Freezable_UsingHandlerList)
{
if (calledHandlers == null)
{
calledHandlers = GetEventStorage();
}
FrugalObjectList<EventHandler> handlers = HandlerList;
for (int i = 0, count = handlers.Count; i < count; i++)
{
calledHandlers.Add(handlers[i]);
}
}
}
/// <summary>
/// Gets an EventStorage object to be used to cache event handlers and sets it to be
/// in use.
/// </summary>
/// <returns>
/// An EventStorage object to be used to cache event handlers that is set
/// to be in use.
/// </returns>
private EventStorage GetEventStorage()
{
EventStorage eventStorage = CachedEventStorage;
// if we reach a case where EventStorage is being used - meaning FireChanged called
// a handler that in turn called FireChanged which is probably a bad thing to have
// happen - just allocate a new one that won't be cached.
if (eventStorage.InUse)
{
// use the cached EventStorage's physical size as an estimate of how big we
// need to be in order to avoid growing the newly created EventStorage
int cachedPhysicalSize = eventStorage.PhysicalSize;
eventStorage = new EventStorage(cachedPhysicalSize);
}
eventStorage.InUse = true;
return eventStorage;
}
public EventStorage SwitchStorage(EventStorage new_storage)
{
var lock_taken = false;
try
{
if (!_lock.IsHeldByCurrentThread) _lock.Enter(ref lock_taken);
var old = _storage;
_storage = new_storage;
Refresh();
return old;
}
finally
{
if (lock_taken) _lock.Exit(true);
}
}
/// <summary>
/// This method walks up the context graph recursively, gathering all change handlers that
/// exist at or above the current node, placing them in calledHandlers. While
/// performing the walk it will also call OnChanged and InvalidateSubProperty on all
/// DO/DP pairs encountered on the walk.
/// </summary>
private void GetChangeHandlersAndInvalidateSubProperties(ref EventStorage calledHandlers)
{
this.OnChanged();
Freezable contextAsFreezable;
if (Freezable_UsingSingletonContext)
{
DependencyObject context = SingletonContext;
contextAsFreezable = context as Freezable;
if (contextAsFreezable != null)
{
contextAsFreezable.GetChangeHandlersAndInvalidateSubProperties(ref calledHandlers);
}
if (SingletonContextProperty != null)
{
context.InvalidateSubProperty(SingletonContextProperty);
}
}
else if (Freezable_UsingContextList)
{
FrugalObjectList<FreezableContextPair> contextList = ContextList;
DependencyObject lastDO = null;
int deadRefs = 0;
for (int i = 0, count = contextList.Count; i < count; i++)
{
FreezableContextPair currentContext = contextList[i];
DependencyObject currentDO = (DependencyObject)currentContext.Owner.Target;
if (currentDO != null)
{
// we only want to grab change handlers once per context reference - so skip
// until we find a new one
if (currentDO != lastDO)
{
contextAsFreezable = currentDO as Freezable;
if (contextAsFreezable != null)
{
contextAsFreezable.GetChangeHandlersAndInvalidateSubProperties(ref calledHandlers);
}
lastDO = currentDO;
}
if (currentContext.Property != null)
{
currentDO.InvalidateSubProperty(currentContext.Property);
}
}
else
{
++deadRefs;
}
}
PruneContexts(contextList, deadRefs);
}
GetHandlers(ref calledHandlers);
}
public ConcurrentEventStore(EventStorage storage, Action<int> notifier_target)
: this(storage, null, notifier_target)
{
}
public SinglethreadEventStore(EventStorage storage, IEnumerable<EventSet> preload, Action<int> notifier_target)
: this(storage, preload, notifier_target, null)
{
}
public ConcurrentEventStore(EventStorage storage, IEnumerable<EventSet> preload, Action<int> notifier_target)
: this(storage, preload, notifier_target, null)
{
}
public SinglethreadEventStore(EventStorage storage, IEnumerable<EventSet> preload)
: this(storage, preload, null)
{
}
public EventsInjector(EventStorage storage)
{
_storage = storage;
}
protected virtual void SetUpPerTest(QueueStorage storage, EventStorage eventStorage)
{
}
