private static async Task <long> AddSqlStreamStore(
Func <IStreamStore> getStreamStore,
Func <ConcurrentUnitOfWork> getUnitOfWork,
EventMapping eventMapping,
EventSerializer eventSerializer,
CommandMessage message,
CancellationToken ct)
{
var aggregate = getUnitOfWork().GetChanges().SingleOrDefault();
if (aggregate == null)
{
return(-1L);
}
if (!message.Metadata.ContainsKey("CommandId"))
{
message.Metadata.Add("CommandId", message.CommandId);
}
var i = 1;
var result = await getStreamStore().AppendToStream(
aggregate.Identifier,
aggregate.ExpectedVersion,
aggregate.Root.GetChangesWithMetadata()
.Select(o =>
new NewStreamMessage(
messageId: Deterministic.Create(Deterministic.Namespaces.Events, $"{message.CommandId}-{i++}"),
type: eventMapping.GetEventName(o.Event.GetType()),
jsonData: eventSerializer.SerializeObject(o.Event),
jsonMetadata: eventSerializer.SerializeObject(GetMetadata(message.Metadata, o.Metadata))))
.ToArray(), ct);
return(result.CurrentPosition);
}
private static async Task <long> AddSqlStreamStore(
Func <IStreamStore> getStreamStore,
Func <ConcurrentUnitOfWork> getUnitOfWork,
EventMapping eventMapping,
EventSerializer eventSerializer,
CommandMessage message,
CancellationToken ct)
{
var uow = getUnitOfWork();
var aggregate = uow.GetChanges().SingleOrDefault();
if (aggregate == null)
{
return(-1L);
}
var streamStore = getStreamStore();
if (!message.Metadata.ContainsKey("CommandId"))
{
message.Metadata.Add("CommandId", message.CommandId);
}
var i = 1;
var events = aggregate.Root.GetChangesWithMetadata().ToImmutableList();
var changes = events
.Select(o =>
new NewStreamMessage(
messageId: Deterministic.Create(Deterministic.Namespaces.Events, $"{message.CommandId}-{i++}"),
type: eventMapping.GetEventName(o.Event.GetType()),
jsonData: eventSerializer.SerializeObject(o.Event),
jsonMetadata: eventSerializer.SerializeObject(GetMetadata(message.Metadata, o.Metadata))))
.ToArray();
var result = await streamStore.AppendToStream(
aggregate.Identifier,
aggregate.ExpectedVersion,
changes,
ct);
if (aggregate.Root is ISnapshotable support)
{
await CreateSnapshot(
support,
new SnapshotStrategyContext(
aggregate,
events,
result.CurrentPosition),
streamStore,
uow,
eventMapping,
eventSerializer,
ct);
}
return(result.CurrentPosition); // Position of the last event written
}
public static string GetProblemInstanceUri(this HttpContext httpContext)
{
// this is the same behaviour that Asp.Net core uses
var traceId = Activity.Current?.Id ?? httpContext.TraceIdentifier;
return(!string.IsNullOrWhiteSpace(traceId)
? $"https://api.basisregisters.vlaanderen.be/v1/foutmelding/{Deterministic.Create(ProblemDetails, traceId):N}"
: $"https://api.basisregisters.vlaanderen.be/v1/foutmelding/{BasicApiProblem.ProblemDetails.GetProblemNumber()}");
}
/// <summary>
/// Casts the "IsDeterministic" property to a valid MySql clause
/// </summary>
/// <param name="value">The enumeration value</param>
/// <returns>The "IsDeterministic" property as a valid string</returns>
private string GetDeterministic(Deterministic value)
{
if (value == Deterministic.YES)
{
return("DETERMINISTIC");
}
return("NOT DETERMINISTIC");
}
public candidate[] getFinalCand(Deterministic agent)
{
var opts = AbstractAlgorithm.GetCarboxylOptions(Cand);
var finals = new candidate[opts.Count];
for (var i = 0; i < finals.Length; i++)
{
finals[i] = agent.CopyAndApplyOption(opts[i], Cand, true);
}
return(finals);
}
public void When_generating_a_deterministic_guid(
string namespaceGuidString,
string value,
int version,
string resultingGuidString)
{
var namespaceGuid = new Guid(namespaceGuidString);
var resultingGuid = new Guid(resultingGuidString);
Deterministic.Create(namespaceGuid, value, version).ShouldBe(resultingGuid);
}
public string GetInstanceUri(HttpContext httpContext)
{
// this is the same behaviour that Asp.Net core uses
var traceId = Activity.Current?.Id ?? httpContext.TraceIdentifier;
var problemBaseInstanceUri = GetInstanceBaseUri();
return(!string.IsNullOrWhiteSpace(traceId)
? $"{problemBaseInstanceUri}/{Deterministic.Create(ProblemDetailsSeed, traceId):N}"
: $"{problemBaseInstanceUri}/{ProblemDetails.GetProblemNumber()}");
}
public BFSNode[] getChildren(Deterministic agent)
{
var opts = AbstractAlgorithm.GetAvailableOptions(Cand);
var nodes = new BFSNode[opts.Count];
for (var i = 0; i < nodes.Length; i++)
{
var child = agent.CopyAndApplyOption(opts[i], Cand, true);
nodes[i] = new BFSNode(child, Depth + 1);
}
return(nodes);
}
public void BitFlipMutationTest1()
{
Organism organism = new Organism();
organism.Chromosomes.Add(new Chromosome(1, "0"));
IRandom rand = new Deterministic(0);
BitFlipMutation mutator = new BitFlipMutation(rand);
mutator.Mutate(organism);
Assert.AreEqual("1", organism.Chromosomes[0].ToString());
}
public async Task WhenMessageIsAppended()
{
var mapping = new EventMapping(EventMapping.DiscoverEventNamesInAssembly(typeof(RoadNetworkEvents).Assembly));
var settings = EventsJsonSerializerSettingsProvider.CreateSerializerSettings();
var archiveStream = new StreamName("archive-1");
var commandStream = new StreamName("road-network-commands");
var id = Guid.NewGuid();
var reaction = new ReactionScenarioBuilder()
.Given(new RecordedEvent(archiveStream, new Messages.UploadRoadNetworkChangesArchive {
ArchiveId = "123"
}).WithMessageId(id))
.Then(new RecordedEvent(commandStream, new Messages.UploadRoadNetworkChangesArchive {
ArchiveId = "123"
}).WithMessageId(id).WithMetadata(new { Position = 1 }))
.Build();
var sut = new Subscriber(_store, commandStream);
using (sut)
{
sut.Start();
//Act
foreach (var stream in reaction.Givens.GroupBy(given => given.Stream))
{
await _store.AppendToStream(
stream.Key,
ExpectedVersion.NoStream,
stream.Select((given, index) => new NewStreamMessage(
Deterministic.Create(Deterministic.Namespaces.Events,
$"{given.Stream}-{index}"),
mapping.GetEventName(given.Event.GetType()),
JsonConvert.SerializeObject(given.Event, settings),
given.Metadata != null ? JsonConvert.SerializeObject(given.Metadata, settings) : null
)).ToArray());
}
//Await
var page = await _store.ReadStreamForwards(commandStream, StreamVersion.Start, 1);
while (page.Status == PageReadStatus.StreamNotFound)
{
page = await _store.ReadStreamForwards(commandStream, StreamVersion.Start, 1);
}
//Assert
//Assert.Equal(_messageId, page.Messages[0].MessageId);
}
await sut.Disposed;
}
public void GeneSwapTest3()
{
Organism organism = new Organism();
organism.Chromosomes.Add(new Chromosome(1, "0011"));
IRandom rand = new Deterministic(0);
GeneSwapMutation mutator = new GeneSwapMutation(rand, 2);
mutator.Mutate(organism);
Assert.AreEqual("1100", organism.Chromosomes[0].ToString());
}
public void BitSwapMutationTest3()
{
Organism organism = new Organism();
organism.Chromosomes.Add(new Chromosome(1, "01010"));
IRandom rand = new Deterministic(1);
BitSwapMutation mutator = new BitSwapMutation(rand);
mutator.Mutate(organism);
string answer = organism.Chromosomes[0].ToString();
Assert.AreEqual("00110", answer);
}
public void InsertionMutationTest2()
{
Organism organism = new Organism();
organism.Chromosomes.Add(new Chromosome(1, "10"));
IRandom rand = new Deterministic(0, 0);
InsertionMutation mutator = new InsertionMutation(rand);
mutator.Mutate(organism);
string answer = organism.Chromosomes[0].ToString();
Assert.AreEqual("010", answer);
}
public void PartiallyMatchedCrossoverTest2()
{
Organism parent1 = new Organism();
Organism parent2 = new Organism();
parent1.Chromosomes.Add(new Chromosome(3, "001110"));
parent2.Chromosomes.Add(new Chromosome(3, "110001"));
IRandom rand = new Deterministic(1, 0);
PartiallyMatchedCrossover linker = new PartiallyMatchedCrossover(rand, 1);
var children = linker.CrossLink(parent1, parent2);
Assert.AreEqual("110001", children.Item1.ToString());
Assert.AreEqual("001110", children.Item2.ToString());
}
public void TwoPointCrossLinkTest1()
{
Organism parent1 = new Organism();
Organism parent2 = new Organism();
parent1.Chromosomes.Add(new Chromosome(1, "111"));
parent2.Chromosomes.Add(new Chromosome(1, "000"));
IRandom rand = new Deterministic(1, 0, 2);
TwoPointCrossover crossLinker = new TwoPointCrossover(rand, 1);
var answer = crossLinker.CrossLink(parent1, parent2);
Assert.AreEqual("001", answer.Item1.Chromosomes[0].ToString());
Assert.AreEqual("110", answer.Item2.Chromosomes[0].ToString());
}
public new Task BindModelAsync(ModelBindingContext bindingContext)
{
base.BindModelAsync(bindingContext).GetAwaiter().GetResult();
if (bindingContext.Result.IsModelSet)
{
return(Task.CompletedTask);
}
bindingContext.Result = ModelBindingResult.Success(
Deterministic.Create(
Deterministic.Namespaces.Commands,
bindingContext.HttpContext.TraceIdentifier));
return(Task.CompletedTask);
}
public static ICommandHandlerBuilder <IRoadRegistryContext, TCommand> UseRoadRegistryContext <TCommand>(
this ICommandHandlerBuilder <TCommand> builder, IStreamStore store, IRoadNetworkSnapshotReader snapshotReader, EventEnricher enricher)
{
if (store == null)
{
throw new ArgumentNullException(nameof(store));
}
if (snapshotReader == null)
{
throw new ArgumentNullException(nameof(snapshotReader));
}
if (enricher == null)
{
throw new ArgumentNullException(nameof(enricher));
}
return(builder.Pipe <IRoadRegistryContext>(next => async(message, ct) =>
{
var map = new EventSourcedEntityMap();
var context = new RoadRegistryContext(map, store, snapshotReader, SerializerSettings, EventMapping);
await next(context, message, ct);
foreach (var entry in map.Entries)
{
var events = entry.Entity.TakeEvents();
if (events.Length != 0)
{
var messageId = message.MessageId.ToString("N");
var version = entry.ExpectedVersion;
Array.ForEach(events, @event => enricher(@event));
var messages = Array.ConvertAll(
events,
@event =>
new NewStreamMessage(
Deterministic.Create(Deterministic.Namespaces.Events,
$"{messageId}-{version++}"),
EventMapping.GetEventName(@event.GetType()),
JsonConvert.SerializeObject(@event, SerializerSettings)
));
await store.AppendToStream(entry.Stream, entry.ExpectedVersion, messages, ct);
}
}
}
));
}
public async Task WriteAsync(IEnumerable <StreamEvent> events)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
var expectedVersions = new ConcurrentDictionary <StreamId, int>();
foreach (var batch in events.Batch(1000))
{
foreach (var stream in batch.GroupBy(item => item.Stream, item => item.Event))
{
if (!expectedVersions.TryGetValue(stream.Key, out var expectedVersion))
{
expectedVersion = ExpectedVersion.NoStream;
}
var watch = Stopwatch.StartNew();
var appendResult = await _streamStore.AppendToStream(
stream.Key,
expectedVersion,
stream
.Select(@event => new NewStreamMessage(
Deterministic.Create(Deterministic.Namespaces.Events, $"{stream.Key}-{expectedVersion++}"),
Mapping.GetEventName(@event.GetType()),
JsonConvert.SerializeObject(@event, SerializerSettings),
JsonConvert.SerializeObject(new Dictionary <string, string> {
{ "$version", "0" }
}, SerializerSettings)
))
.ToArray()
);
_logger.LogInformation("Append took {0}ms for stream {1}@{2}",
watch.ElapsedMilliseconds,
stream.Key,
appendResult.CurrentVersion);
expectedVersions[stream.Key] = appendResult.CurrentVersion;
}
}
}
// private class PointMComparer : BaseTypeComparer
// {
// public PointMComparer(RootComparer comparer)
// :base(comparer)
// {
// }
//
// public override void CompareType(CompareParms parms)
// {
// var left = (PointM)parms.Object1;
// var right = (PointM)parms.Object2;
// if(!Equals(left.X, right.X)
// || !Equals(left.Y, right.Y)
// || !Equals(left.Z, right.Z)
// || !Equals(left.M, right.M))
// {
// var difference = new Difference
// {
// Object1 = left,
// Object1TypeName = left.GetType().Name,
// Object1Value = left.ToString(),
// Object2 = right,
// Object2TypeName = right.GetType().Name,
// Object2Value = right.ToString(),
// ParentObject1 = parms.ParentObject1,
// ParentObject2 = parms.ParentObject2
// };
// parms.Result.Differences.Add(difference);
// }
// }
//
// public override bool IsTypeMatch(Type type1, Type type2)
// {
// return type1 == typeof(PointM) && type2 == typeof(PointM);
// }
// }
private async Task <long> WriteGivens(RecordedEvent[] givens)
{
var checkpoint = SqlStreamStore.Streams.Position.Start;
foreach (var stream in givens.GroupBy(given => given.Stream))
{
var result = await _store.AppendToStream(
_converter(new StreamName(stream.Key)).ToString(),
ExpectedVersion.NoStream,
stream.Select((given, index) => new NewStreamMessage(
Deterministic.Create(Deterministic.Namespaces.Events,
$"{given.Stream}-{index}"),
_mapping.GetEventName(given.Event.GetType()),
JsonConvert.SerializeObject(given.Event, _settings)
)).ToArray());
checkpoint = result.CurrentPosition + 1;
}
return(checkpoint);
}
private static async Task CreateSnapshot(
ISnapshotable snapshotSupport,
SnapshotStrategyContext context,
IStreamStore streamStore,
ConcurrentUnitOfWork uow,
EventMapping eventMapping,
EventSerializer eventSerializer,
CancellationToken ct)
{
if (!snapshotSupport.Strategy.ShouldCreateSnapshot(context))
{
return;
}
var snapshot = snapshotSupport.TakeSnapshot();
if (snapshot == null)
{
throw new InvalidOperationException("Snapshot missing.");
}
var snapshotContainer = new SnapshotContainer
{
Data = eventSerializer.SerializeObject(snapshot),
Info =
{
Type = eventMapping.GetEventName(snapshot.GetType()),
Position = context.SnapshotPosition
}
};
await streamStore.AppendToStream(
uow.GetSnapshotIdentifier(context.Aggregate.Identifier),
ExpectedVersion.Any,
new NewStreamMessage(
Deterministic.Create(Deterministic.Namespaces.Events, $"snapshot-{context.SnapshotPosition}"),
$"SnapshotContainer<{snapshotContainer.Info.Type}>",
eventSerializer.SerializeObject(snapshotContainer)),
ct);
}
private void MenuItem_Click_8(object sender, RoutedEventArgs e)
{
if (Sim != null)
{
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.FileName = "Document"; // Default file name
dlg.DefaultExt = ".xml"; // Default file extension
dlg.Filter = "XML documents (.xml)|*.xml"; // Filter files by extension
// Show save file dialog box
bool?result = dlg.ShowDialog();
// Process save file dialog box results
if (result == true)
{
// Save document
string filename = dlg.FileName;
string tempRequest = System.IO.Path.GetTempPath() + "temp.xml";
Sim.SilentSaveAs(tempRequest);
Deterministic.CreateDeterministicSim(tempRequest, filename);
}
}
}
public Guid CreateCommandId()
=> Deterministic.Create(Namespace, $"AssignPersistentLocalId-{ToString()}");
public Guid CreateCommandId()
=> Deterministic.Create(Namespace, $"ImportMunicipality-{ToString()}");
public Guid CreateDeterministicId() => Deterministic.Create(CrabMunicipalityIdNamespace, $"gemeenteid-{Value}");
public Guid CreateCommandId()
=> Deterministic.Create(Namespace, $"ImportStreetNameFromCrab-{ToString()}");
public Guid CreateDeterministicId()
=> Deterministic.Create(Namespace, $"VbrCaPaKey-{ToString()}");
public Guid CreateCommandId()
=> Deterministic.Create(Namespace, $"ProposeStreetName-{ToString()}");
public Guid CreateDeterministicId() => Deterministic.Create(CrabHouseNumberIdNamespace, $"huisnummerid-{Value}");
public override Guid CreateCommandId()
=> Deterministic.Create(Namespace, $"ImportSubaddressMailCantonFromCrab-{ToString()}");
public Guid CreateDeterministicId() => Deterministic.Create(CrabBuildingNamespace, $"terreinobjectid-{Value}");
/// <summary>
/// Casts the "IsDeterministic" property to a valid MySql clause
/// </summary>
/// <param name="value">The enumeration value</param>
/// <returns>The "IsDeterministic" property as a valid string</returns>
private string GetDeterministic(Deterministic value)
{
if (value == Deterministic.YES)
return "DETERMINISTIC";
return "NOT DETERMINISTIC";
}
