major: Release v9.0.0

src/Directory.Build.props

@@ -16,7 +16,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All"/>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All"/>
   </ItemGroup>
 
 </Project>

src/Elders.Cronus.Performance/Elders.Cronus.Performance.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.7" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Elders.Cronus\Elders.Cronus.csproj" />
+  </ItemGroup>
+
+</Project>

src/Elders.Cronus.Performance/LoggingBenchmark.cs

@@ -0,0 +1,67 @@
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.Logging;
+
+//BenchmarkRunner.Run<LoggingBench>();
+
+[MemoryDiagnoser]
+public class LoggingBench
+{
+    private readonly ILogger _logger;
+    private string _name = "Batman";
+    private int _age = 82;
+
+    public LoggingBench()
+    {
+        _logger = LoggerFactory.Create(builder =>
+        {
+            builder.ClearProviders();
+            builder.AddProvider(new MyLoggerProvider());
+        }).CreateLogger(typeof(LoggingBench));
+    }
+
+    [Benchmark(Baseline = true)]
+    public void Default() => Log.Log0(_logger, _name, _age);
+
+    [Benchmark]
+    public void SkipEnabledCheck() => Log.Log1(_logger, _name, _age);
+
+    private static class Log
+    {
+        static LogDefineOptions logOptions = new LogDefineOptions()
+        {
+            SkipEnabledCheck = true
+        };
+
+        private static readonly Action<ILogger, string, int, Exception?> s_log0 = LoggerMessage.Define<string, int>(
+            LogLevel.Information,
+            new EventId(1001),
+            "Name {Name} is {Age} years old");
+
+        private static readonly Action<ILogger, string, int, Exception?> s_log1 = LoggerMessage.Define<string, int>(
+            LogLevel.Information,
+            new EventId(1001),
+            "Name {Name} is {Age} years old",
+            logOptions);
+
+        public static void Log0(ILogger logger, string name, int age) => s_log0(logger, name, age, null);
+        public static void Log1(ILogger logger, string name, int age) => s_log1(logger, name, age, null);
+    }
+}
+
+public class MyLogger : ILogger
+{
+    public IDisposable BeginScope<TState>(TState state) => throw new NotImplementedException();
+    public bool IsEnabled(LogLevel logLevel) => false;
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        => LogCore(formatter(state, exception));
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void LogCore(string _) { }
+}
+
+public class MyLoggerProvider : ILoggerProvider
+{
+    public ILogger CreateLogger(string categoryName) => new MyLogger();
+    public void Dispose() { }
+}

src/Elders.Cronus.Performance/Program.cs

@@ -0,0 +1,19 @@
+//using BenchmarkDotNet.Attributes;
+//using Elders.Cronus.Performance;
+
+//LoggingBenchmark lb = new LoggingBenchmark();
+//lb.LogInterpolation();
+
+//BenchmarkDotNet.Running.BenchmarkRunner.Run<TestRunner>();
+
+//[MemoryDiagnoser]
+//public class TestRunner
+//{
+//    LoggingBenchmark lb = new LoggingBenchmark();
+
+//    [Benchmark]
+//    public void LogInterpolation()
+//    {
+
+//    }
+//}

src/Elders.Cronus.Performance/UrnInit.cs

@@ -0,0 +1,24 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Running;
+using Elders.Cronus;
+
+BenchmarkRunner.Run<UrnInitBench>();
+
+[MemoryDiagnoser]
+public class UrnInitBench
+{
+    string urnString = "urn:elders:user:8eef39fd-b4fa-4323-b062-85e756960862";
+
+    [Benchmark]
+    public void Constructor()
+    {
+        var urn = new Urn(urnString);
+    }
+
+    [Benchmark]
+    public void Parse()
+    {
+        var urn = new Urn(urnString);
+    }
+}
+

src/Elders.Cronus.Tests/Discoveries/When_discoving_jobs_from_discoveryContext.cs

@@ -1,6 +1,5 @@
 using Elders.Cronus.Cluster.Job;
 using Elders.Cronus.Cluster.Job.InMemory;
-using Elders.Cronus.EventStore.Index;
 using Machine.Specifications;
 using Microsoft.Extensions.Configuration;
 using System;

src/Elders.Cronus.Tests/Elders.Cronus.Tests.csproj

@@ -6,11 +6,11 @@
     <RootNamespace>Elders.Cronus</RootNamespace>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Cronus.DomainModeling" Version="8.1.0" />
-    <PackageReference Include="Machine.Specifications" Version="1.0.0" />
+    <PackageReference Include="Cronus.DomainModeling" Version="9.0.0" />
+    <PackageReference Include="Machine.Specifications" Version="1.1.1" />
     <PackageReference Include="Machine.Specifications.Runner.VisualStudio" Version="2.10.2" />
     <PackageReference Include="Machine.Specifications.Should" Version="1.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Elders.Cronus\Elders.Cronus.csproj" />

src/Elders.Cronus.Tests/EventStream.cs

@@ -14,8 +14,8 @@ public class When_build_aggregate_root_from_events
             id = new TestAggregateId();
 
             var commits = new List<AggregateCommit>();
-            commits.Add(new AggregateCommit(id as IBlobId, 1, new List<IEvent>() { new TestCreateEvent(id) }));
-            commits.Add(new AggregateCommit(id as IBlobId, 2, new List<IEvent>() { new TestUpdateEvent(id, "When_build_aggregate_root_from_events") }));
+            commits.Add(new AggregateCommit(id, 1, new List<IEvent>() { new TestCreateEvent(id) }, new List<IPublicEvent>(), DateTimeOffset.Now.ToFileTime()));
+            commits.Add(new AggregateCommit(id, 2, new List<IEvent>() { new TestUpdateEvent(id, "When_build_aggregate_root_from_events") }, new List<IPublicEvent>(), DateTimeOffset.Now.ToFileTime()));
 
             eventStream = new EventStream(commits);
         };
@@ -37,7 +37,7 @@ public class When_build_aggregate_root_from_history_without_the_initial_event
         {
             id = new TestAggregateId();
             var commits = new List<AggregateCommit>();
-            commits.Add(new AggregateCommit(id as IBlobId, 2, new List<IEvent>() { new TestUpdateEvent(id, "When_build_aggregate_root_from_history_without_the_initial_event") }));
+            commits.Add(new AggregateCommit(id, 2, new List<IEvent>() { new TestUpdateEvent(id, "When_build_aggregate_root_from_history_without_the_initial_event") }, new List<IPublicEvent>(), DateTimeOffset.Now.ToFileTime()));
             eventStream = new EventStream(commits);
         };
 

src/Elders.Cronus.Tests/InMemory/InMemoryEventStorePersister.cs

@@ -1,8 +1,9 @@
+using Elders.Cronus.EventStore.Index;
+using System;
 using System.Threading.Tasks;
 
 namespace Elders.Cronus.EventStore.InMemory
 {
-
     public class InMemoryEventStore : IEventStore
     {
         private InMemoryEventStoreStorage eventStoreStorage;
@@ -21,7 +22,7 @@ public InMemoryEventStore(InMemoryEventStoreStorage eventStoreStorage)
         /// </summary>
         /// <param name="aggregateId">The aggregate identifier.</param>
         /// <returns></returns>
-        public Task<EventStream> LoadAsync(IAggregateRootId aggregateId)
+        public Task<EventStream> LoadAsync(IBlobId aggregateId)
         {
             return Task.FromResult(new EventStream(eventStoreStorage.Seek(aggregateId)));
         }
@@ -37,9 +38,23 @@ public Task AppendAsync(AggregateCommit aggregateCommit)
             return Task.CompletedTask;
         }
 
-        public Task AppendAsync(AggregateCommitRaw aggregateCommitRaw)
+        public Task AppendAsync(AggregateEventRaw aggregateCommitRaw)
         {
             return Task.FromException(new System.NotImplementedException());
         }
+
+        public Task<bool> DeleteAsync(AggregateEventRaw eventRaw)
+        {
+            throw new System.NotImplementedException();
+        }
+        public Task<LoadAggregateRawEventsWithPagingResult> LoadWithPagingDescendingAsync(IBlobId aggregateId, PagingOptions pagingOptions)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public Task<AggregateEventRaw> LoadAggregateEventRaw(IndexRecord indexRecord)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/Elders.Cronus.Tests/InMemory/InMemoryEventStorePlayer.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
 
 namespace Elders.Cronus.EventStore.InMemory
@@ -14,31 +13,15 @@ public InMemoryEventStorePlayer(InMemoryEventStoreStorage eventStoreStorage)
             this.eventStoreStorage = eventStoreStorage;
         }
 
-        public async IAsyncEnumerable<AggregateCommit> LoadAggregateCommitsAsync(int batchSize = 5000)
-        {
-            foreach (var @event in eventStoreStorage.GetOrderedEvents())
-                yield return @event;
-        }
-
-        public Task<LoadAggregateCommitsResult> LoadAggregateCommitsAsync(ReplayOptions replayOptions)
-        {
-            throw new NotImplementedException();
-        }
-
-        public IAsyncEnumerable<AggregateCommitRaw> LoadAggregateCommitsRawAsync(int batchSize = 5000)
+        public Task EnumerateEventStore(PlayerOperator @operator, PlayerOptions replayOptions)
         {
             throw new NotImplementedException();
         }
 
-        Task<LoadAggregateCommitsResult> IEventStorePlayer.LoadAggregateCommitsAsync(string paginationToken, int batchSize)
+        public async IAsyncEnumerable<AggregateCommit> LoadAggregateCommitsAsync(int batchSize = 5000)
         {
-            LoadAggregateCommitsResult aggregateCommit = new LoadAggregateCommitsResult
-            {
-                Commits = eventStoreStorage.GetOrderedEvents().ToList(),
-                PaginationToken = paginationToken
-            };
-
-            return Task.FromResult(aggregateCommit);
+            foreach (var @event in eventStoreStorage.GetOrderedEvents())
+                yield return @event;
         }
     }
 }

src/Elders.Cronus.Tests/InMemory/InMemoryEventStoreStorage.cs

@@ -52,7 +52,7 @@ internal protected void Flush(AggregateCommit aggregateCommit)
             eventsForReplay.Enqueue(aggregateCommit);
         }
 
-        internal protected List<AggregateCommit> Seek(IAggregateRootId aggregateId)
+        internal protected List<AggregateCommit> Seek(IBlobId aggregateId)
         {
             var idHash = Convert.ToBase64String(aggregateId.RawId);
             ConcurrentQueue<AggregateCommit> commits;

src/Elders.Cronus.Tests/InMemoryEventStoreSuite/When_loading_aggregate_root_from_event_store.cs

@@ -17,10 +17,10 @@ public class When_loading_aggregate_root_from_event_store
             versionService = new InMemoryAggregateRootAtomicAction();
             eventStoreStorage = new InMemoryEventStoreStorage();
             eventStore = new InMemoryEventStore(eventStoreStorage);
-            eventStoreFactory = new EventStoreFactory(eventStore, new NoAggregateCommitTransformer(), null);
+            eventStoreFactory = new EventStoreFactory(eventStore, null);
             eventStorePlayer = new InMemoryEventStorePlayer(eventStoreStorage);
             integrityPpolicy = new EventStreamIntegrityPolicy();
-            aggregateRepository = new AggregateRepository(eventStoreFactory, versionService, integrityPpolicy);
+            aggregateRepository = new AggregateRepository(eventStoreFactory, versionService, integrityPpolicy, new EmptyAggregateTransformer());
             id = new TestAggregateId();
             aggregateRoot = new TestAggregateRoot(id);
             await aggregateRepository.SaveAsync<TestAggregateRoot>(aggregateRoot);