/// <summary>
/// Must be overridden to use as an async projection. Takes a range of events, and sorts them
/// into an EventSlice for each detected aggregate document
/// </summary>
/// <param name="store"></param>
/// <param name="database"></param>
/// <param name="range"></param>
/// <param name="cancellation"></param>
/// <returns></returns>
/// <exception cref="NotSupportedException"></exception>
public ValueTask <IReadOnlyList <TenantSliceGroup <TDoc, TId> > > GroupEventRange(DocumentStore store,
IMartenDatabase database,
EventRange range, CancellationToken cancellation)
{
using var session = store.OpenSession(SessionOptions.ForDatabase(database));
return(Slicer.SliceAsyncEvents(session, range.Events));
}
public async Task PublishEvents()
{
var streams = TripStream.RandomStreams(5);
while (streams.Any())
{
var count = 0;
var options = SessionOptions.ForDatabase(_database);
await using var session = _store.OpenSession(options);
foreach (var stream in streams.ToArray())
{
if (stream.TryCheckOutEvents(out var events))
{
count += events.Length;
session.Events.Append(stream.StreamId, events);
}
if (stream.IsFinishedPublishing())
{
streams.Remove(stream);
}
}
await session.SaveChangesAsync();
_board.Update(_name, count);
}
}
public async Task <long> Start(ProjectionDaemon daemon)
{
if (daemon.Database.Identifier != "Marten")
{
ProjectionShardIdentity = $"{ProjectionShardIdentity}@{daemon.Database.Identifier}";
}
_logger.LogInformation("Starting projection agent for '{ProjectionShardIdentity}'", ProjectionShardIdentity);
_sessionOptions = SessionOptions.ForDatabase(daemon.Database);
initializeDataflowBlocks(daemon);
var lastCommitted = await daemon.Database.ProjectionProgressFor(_projectionShard.Name, _cancellation).ConfigureAwait(false);
foreach (var storageType in _source.Options.StorageTypes)
{
await daemon.Database.EnsureStorageExistsAsync(storageType, _cancellation).ConfigureAwait(false);
}
foreach (var publishedType in _source.PublishedTypes())
{
await daemon.Database.EnsureStorageExistsAsync(publishedType, _cancellation).ConfigureAwait(false);
}
_subscription = _tracker.Subscribe(this);
_commandBlock.Post(Command.Started(_tracker.HighWaterMark, lastCommitted));
_logger.LogInformation("Projection agent for '{ProjectionShardIdentity}' has started from sequence {LastCommitted} and a high water mark of {HighWaterMark}", ProjectionShardIdentity, lastCommitted, _tracker.HighWaterMark);
Status = AgentStatus.Running;
Position = lastCommitted;
return(lastCommitted);
}
async ValueTask <EventRangeGroup> IAggregationRuntime.GroupEvents(DocumentStore store, IMartenDatabase database, EventRange range,
CancellationToken cancellationToken)
{
using var session = store.OpenSession(SessionOptions.ForDatabase(database));
var groups = await Slicer.SliceAsyncEvents(session, range.Events).ConfigureAwait(false);
return(new TenantSliceRange <TDoc, TId>(store, this, range, groups, cancellationToken));
}
public void for_database()
{
var database = Substitute.For <IMartenDatabase>();
var options = SessionOptions.ForDatabase(database);
options.Tenant.Database.ShouldBeTheSameAs(database);
options.Tenant.TenantId.ShouldBe(Tenancy.DefaultTenantId);
options.OwnsConnection.ShouldBeTrue();
options.OwnsTransactionLifecycle.ShouldBeTrue();
}
private QuerySession querySession()
{
return((QuerySession)_store.QuerySession(SessionOptions.ForDatabase(_database)));
}
