public EventStoreTests()
{
var eventSerializer = new EventSerializer(new JsonTextSerializer());
var snapshotSerializer = new SnapshotSerializer(new JsonTextSerializer());
_inMemoryDomainEventStore = new InMemoryEventStore();
var mockLogger = new Mock <ILogger>();
mockLogger.Setup(e => e.IsEnabled(It.IsAny <LogLevel>())).Returns(true);
mockLogger.Setup(e => e.Log(It.IsAny <LogLevel>(), It.IsAny <string>(), It.IsAny <Exception>()));
var mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(e => e.Create(It.IsAny <string>())).Returns(mockLogger.Object);
_mockEventPublisher = new Mock <IEventPublisher>();
_mockEventPublisher.Setup(e => e.PublishAsync(It.IsAny <IEnumerable <IDomainEvent> >())).Returns(Task.CompletedTask);
var session = new Session(mockLoggerFactory.Object, _inMemoryDomainEventStore, _mockEventPublisher.Object, eventSerializer, snapshotSerializer);
_repository = new Repository(mockLoggerFactory.Object, session);
var unitOfWorkMock = new Mock <IUnitOfWork>();
unitOfWorkMock.Setup(e => e.CommitAsync())
.Callback(async() =>
{
await session.SaveChangesAsync().ConfigureAwait(false);
})
.Returns(Task.CompletedTask);
_unitOfWork = unitOfWorkMock.Object;
}
private void saveInterprocessSnapshot(int pid, string leftSHA, string rightSHA, MergeRequestKey mrk,
string accessToken, string sessionName)
{
// leftSHA - Base commit SHA in the source branch
// rightSHA - SHA referencing HEAD of this merge request
Snapshot snapshot = new Snapshot(
mrk.IId,
mrk.ProjectKey.HostName,
accessToken,
mrk.ProjectKey.ProjectName,
new Core.Matching.DiffRefs(leftSHA, rightSHA),
textBoxStorageFolder.Text,
sessionName);
SnapshotSerializer serializer = new SnapshotSerializer();
try
{
serializer.SerializeToDisk(snapshot, pid);
}
catch (Exception ex)
{
ExceptionHandlers.Handle("Cannot serialize Snapshot object", ex);
}
}
public SnapshotSendChannel(SnapshotSerializer snapshotSerializer)
{
_sentSnapshot = new Dictionary <int, ISnapshot>();
_snapshotQueue = new Queue <int>();
_snapSerializer = snapshotSerializer;
AckedSnapshotId = -1;
}
private void saveInterprocessSnapshot(int pid, string leftSHA, string rightSHA, MergeRequestKey mrk,
DataCache dataCache)
{
// leftSHA - Base commit SHA in the source branch
// rightSHA - SHA referencing HEAD of this merge request
Snapshot snapshot = new Snapshot(
mrk.IId,
mrk.ProjectKey.HostName,
mrk.ProjectKey.ProjectName,
new Core.Matching.DiffRefs(leftSHA, rightSHA),
textBoxStorageFolder.Text,
getDataCacheName(dataCache),
dataCache.ConnectionContext?.GetHashCode() ?? 0);
SnapshotSerializer serializer = new SnapshotSerializer();
try
{
serializer.SerializeToDisk(snapshot, pid);
}
catch (Exception ex) // Any exception from serialization code
{
ExceptionHandlers.Handle("Cannot serialize Snapshot object", ex);
}
}
public SnapshotReplicator(INetworkObjectSerializerManager manager, string version)
{
var serializer = new SnapshotSerializer(manager, version);
_recvChannel = new SnapshotRecvChannel(serializer);
_sendChannel = new SnapshotSendChannel(serializer);
}
public void Customized_SerializerSettings_WithoutConverter()
{
var sut = new SnapshotSerializer(new WithoutEnumConversion());
var myState = new { MyProp = MyEnum.FirstValue, OtherProp = MyEnum.LastValue, MyString = "String" };
var snapEnumsAsIntegers = sut.SerializeObject(myState);
snapEnumsAsIntegers.Should().Be("{\n \"MyProp\": 1,\n \"OtherProp\": 99,\n \"MyString\": \"String\"\n}\n");
}
public void Default_Serializer_EnumAsStrings()
{
var sut = new SnapshotSerializer(new DefaultSnapshotSerializerSettings());
var myState = new { MyProp = MyEnum.FirstValue, OtherProp = MyEnum.LastValue, MyString = "String" };
var snapEnumsAsStrings = sut.SerializeObject(myState);
snapEnumsAsStrings.Should().Be("{\n \"MyProp\": \"FirstValue\",\n \"OtherProp\": \"LastValue\",\n \"MyString\": \"String\"\n}\n");
}
private void saveInterprocessSnapshot(int pid, string leftSHA, string rightSHA)
{
Snapshot snapshot;
snapshot.AccessToken = GetCurrentAccessToken();
snapshot.Refs.LeftSHA = leftSHA; // Base commit SHA in the source branch
snapshot.Refs.RightSHA = rightSHA; // SHA referencing HEAD of this merge request
snapshot.Host = GetCurrentHostName();
snapshot.MergeRequestIId = GetCurrentMergeRequestIId();
snapshot.Project = GetCurrentProjectName();
snapshot.TempFolder = textBoxLocalGitFolder.Text;
SnapshotSerializer serializer = new SnapshotSerializer();
serializer.SerializeToDisk(snapshot, pid);
}
private async Task <Session> ArrangeSessionAsync <TAggregate>(Guid aggregateId, IEventUpdateManager eventUpdateManager = null, params IDomainEvent[] arrangeEvents)
where TAggregate : Aggregate, new()
{
var metadataProviders = new IMetadataProvider[]
{
new AggregateTypeMetadataProvider(),
new EventTypeMetadataProvider(),
new CorrelationIdMetadataProvider()
};
var loggerFactory = new NoopLoggerFactory();
var eventPublisher = new EventPublisher(new StubEventRouter());
var eventStore = new InMemoryEventStore();
var eventSerializer = new EventSerializer(new JsonTextSerializer());
var snapshotSerializer = new SnapshotSerializer(new JsonTextSerializer());
var projectionSerializer = new ProjectionSerializer(new JsonTextSerializer());
var session = new Session(loggerFactory, eventStore, eventPublisher, eventSerializer, snapshotSerializer, projectionSerializer, eventUpdateManager: eventUpdateManager);
var aggregate = (TAggregate)Activator.CreateInstance(typeof(TAggregate), args: aggregateId);
aggregate.UpdateVersion(arrangeEvents.Length - 1);
var serializedEvents = arrangeEvents.Select((e, index) =>
{
index++;
var metadatas =
metadataProviders.SelectMany(md => md.Provide(aggregate, e, EventSource.Metadata.Empty)).Concat(new[]
{
new KeyValuePair <string, object>(MetadataKeys.EventId, Guid.NewGuid()),
new KeyValuePair <string, object>(MetadataKeys.EventVersion, (aggregate.Version + index))
});
return(eventSerializer.Serialize(aggregate, e, new EventSource.Metadata(metadatas)));
});
eventStore.BeginTransaction();
await eventStore.SaveAsync(serializedEvents);
await eventStore.CommitAsync();
return(session);
}
private void processDiffQueue()
{
if (!_requestedDiff.Any())
{
return;
}
DiffRequest diffRequest = _requestedDiff.Peek();
try
{
SnapshotSerializer serializer = new SnapshotSerializer();
Snapshot snapshot;
try
{
snapshot = serializer.DeserializeFromDisk(diffRequest.GitPID);
}
catch (Exception ex)
{
ExceptionHandlers.Handle("Cannot read serialized Snapshot object", ex);
MessageBox.Show(
"Make sure that diff tool was launched from Merge Request Helper which is still running",
"Cannot create a discussion",
MessageBoxButtons.OK, MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1, MessageBoxOptions.ServiceNotification);
return;
}
if (_storageFactory == null || _storageFactory.ParentFolder != snapshot.TempFolder)
{
Trace.TraceWarning("[MainForm] File Storage folder was changed after launching diff tool");
MessageBox.Show("It seems that file storage folder was changed after launching diff tool. " +
"Please restart diff tool.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1, MessageBoxOptions.ServiceNotification);
return;
}
Core.Matching.MatchInfo matchInfo;
try
{
DiffArgumentParser diffArgumentParser = new DiffArgumentParser(diffRequest.DiffArguments);
matchInfo = diffArgumentParser.Parse(getDiffTempFolder(snapshot));
Debug.Assert(matchInfo != null);
}
catch (ArgumentException ex)
{
ExceptionHandlers.Handle("Cannot parse diff tool arguments", ex);
MessageBox.Show("Bad arguments passed from diff tool", "Cannot create a discussion",
MessageBoxButtons.OK, MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1, MessageBoxOptions.ServiceNotification);
return;
}
ProjectKey projectKey = new ProjectKey(snapshot.Host, snapshot.Project);
ILocalCommitStorage storage = getCommitStorage(projectKey, false);
if (storage.Git == null)
{
Trace.TraceError("[MainForm] storage.Git is null");
Debug.Assert(false);
return;
}
DataCache dataCache = getDataCacheByName(snapshot.DataCacheName);
if (dataCache == null || getCurrentUser() == null)
{
// It is unexpected to get here when we are not connected to a host
Debug.Assert(false);
return;
}
DiffCallHandler handler = new DiffCallHandler(storage.Git, _modificationNotifier, getCurrentUser(),
(mrk) =>
{
dataCache.DiscussionCache?.RequestUpdate(mrk,
Constants.DiscussionCheckOnNewThreadFromDiffToolInterval, null);
});
handler.Handle(matchInfo, snapshot);
}
finally
{
if (_requestedDiff.Any())
{
_requestedDiff.Dequeue();
BeginInvoke(new Action(() => processDiffQueue()));
}
}
}
public SnapshotRecvChannel(SnapshotSerializer serializer)
{
_receivedSnapMap = new Dictionary <int, ISnapshot>();
_snapSerializer = serializer;
}
protected override Task Context()
{
_parameter = new Parameter();
sut = new SnapshotSerializer();
return(_completed);
}
private static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var arguments = Environment.GetCommandLineArgs();
if (arguments.Length < 2)
{
using (Mutex mutex = new Mutex(false, "Global\\" + mutex1_guid))
{
if (!mutex.WaitOne(0, false))
{
return;
}
Application.ThreadException += (sender, e) => HandleUnhandledException(e.Exception);
setupTraceListener("mrHelper.main.log");
try
{
Application.Run(new MainForm());
}
catch (Exception ex) // whatever unhandled exception
{
HandleUnhandledException(ex);
}
}
}
else if (arguments[1] == "diff")
{
using (Mutex mutex = new Mutex(false, "Global\\" + mutex2_guid))
{
if (!mutex.WaitOne(0, false))
{
return;
}
Application.ThreadException += (sender, e) => HandleUnhandledException(e.Exception);
setupTraceListener("mrHelper.diff.log");
DiffArgumentParser diffArgumentParser = new DiffArgumentParser(arguments);
DiffToolInfo diffToolInfo;
try
{
diffToolInfo = diffArgumentParser.Parse();
}
catch (ArgumentException ex)
{
ExceptionHandlers.Handle(ex, "Cannot parse diff tool arguments");
MessageBox.Show("Bad arguments, see details in logs", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
int gitPID = mrHelper.Core.Interprocess.Helpers.GetGitParentProcessId(Process.GetCurrentProcess().Id);
SnapshotSerializer serializer = new SnapshotSerializer();
Snapshot snapshot;
try
{
snapshot = serializer.DeserializeFromDisk(gitPID);
}
catch (System.IO.IOException ex)
{
ExceptionHandlers.Handle(ex, "Cannot de-serialize snapshot");
MessageBox.Show("Cannot create a discussion. "
+ "Make sure that you use diff tool instance launched from mrHelper and mrHelper is still running.");
return;
}
IInterprocessCallHandler diffCallHandler = new DiffCallHandler(diffToolInfo);
try
{
diffCallHandler.Handle(snapshot);
}
catch (Exception ex) // whatever unhandled exception
{
HandleUnhandledException(ex);
}
}
}
}
