/// <inheritdoc />
public Commits GetUnprocessedCommits(CommitSequenceNumber commitSequenceNumber)
{
List <CommittedEventStream> commits;
List <CommittedEventStream> newCommits;
using (var eventStore = _getEventStore())
{
commits = eventStore.FetchAllCommitsAfter(commitSequenceNumber).ToList();
}
if (!commits.Any())
{
return(new Commits(new CommittedEventStream[] {}));
}
do
{
newCommits = new List <CommittedEventStream>();
var lastCommitSequenceNumber = commits.OrderByDescending(_ => _.Sequence).First().Sequence; // This could potentially become an endless loop of fetching new commits if N is big enough
using (var eventStore = _getEventStore())
{
newCommits.AddRange(eventStore.FetchAllCommitsAfter(lastCommitSequenceNumber));
}
if (newCommits.Any())
{
commits.AddRange(newCommits);
}
}while(newCommits.Any());
return(new Commits(commits));
}
/// <summary>
/// Builds a <see cref="FilterDefinition{BsonDocument}" /> corresponding to the <see cref="CommitSequenceNumber" /> supplied
/// </summary>
/// <param name="commit">A <see cref="CommitSequenceNumber" /></param>
/// <returns>A <see cref="FilterDefinition{BsonDocument}" /> corresponding to the <see cref="CommitSequenceNumber" /></returns>
public static FilterDefinition <BsonDocument> ToFilter(this CommitSequenceNumber commit)
{
var builder = Builders <BsonDocument> .Filter;
var filter = builder.Gt(Constants.ID, commit.Value);
return(filter);
}
/// <inheritdoc />
public Commits GetUnprocessedCommits(CommitSequenceNumber commitSequenceNumber)
{
List <CommittedEventStream> commits;
List <CommittedEventStream> newCommits;
using (var eventStore = _getEventStore())
{
commits = eventStore.FetchAllCommitsAfter(commitSequenceNumber).ToList();
}
if (commits.Count == 0)
{
return(new Commits(Array.Empty <CommittedEventStream>()));
}
do
{
newCommits = new List <CommittedEventStream>();
var lastCommitSequenceNumber = commits.OrderByDescending(_ => _.Sequence).First().Sequence;
using (var eventStore = _getEventStore())
{
newCommits.AddRange(eventStore.FetchAllCommitsAfter(lastCommitSequenceNumber));
}
if (newCommits.Count > 0)
{
commits.AddRange(newCommits);
}
}while (newCommits.Count > 0);
return(new Commits(commits));
}
/// <inheritdoc />
public Commits FetchAllCommitsAfter(CommitSequenceNumber commit)
{
using (var es = _database.GetContext())
{
return(BuildCommits(es.Commits.Include(c => c.Events).Where(c => c.Id > (long)commit.Value).OrderBy(c => c.Id)));
}
}
CommittedEvent ToCommittedEvent(CommitSequenceNumber commitSequenceNumber, EventEnvelope @event)
{
var eventType = _artifactTypeMap.GetTypeFor(@event.Metadata.Artifact);
var eventInstance = _objectFactory.Build(eventType, @event.Event) as IEvent;
var committedEventVersion = new CommittedEventVersion(commitSequenceNumber, @event.Metadata.VersionedEventSource.Version.Commit, @event.Metadata.VersionedEventSource.Version.Sequence);
return(new CommittedEvent(committedEventVersion, @event.Metadata, eventInstance));
}
/// <summary>
///
/// </summary>
/// <param name="sequence"></param>
/// <param name="source"></param>
/// <param name="id"></param>
/// <param name="timestamp"></param>
/// <param name="correlationId"></param>
public CommitMetadata(CommitSequenceNumber sequence, VersionedEventSource source, CommitId id, DateTimeOffset timestamp, CorrelationId correlationId)
{
Sequence = sequence;
Source = source;
Id = id;
Timestamp = timestamp;
CorrelationId = correlationId;
}
/// <inheritdoc />
CommittedEventStream Commit(UncommittedEventStream uncommittedEvents, CommitSequenceNumber commitSequenceNumber)
{
lock (lock_object)
{
ThrowIfDuplicate(uncommittedEvents.Id);
ThrowIfConcurrencyConflict(uncommittedEvents.Source);
var commit = new CommittedEventStream(commitSequenceNumber, uncommittedEvents.Source, uncommittedEvents.Id, uncommittedEvents.CorrelationId, uncommittedEvents.Timestamp, uncommittedEvents.Events);
_commits.Add(commit);
_duplicates.Add(commit.Id);
_versions.AddOrUpdate(commit.Source.Key, commit.Source, (id, ver) => commit.Source);
return(commit);
}
}
/// <summary>
/// Initializes an instance of <see cref="OriginalContext"/>
/// </summary>
/// <param name="application"><see cref="Application"/> that is the source of the event</param>
/// <param name="boundedContext"><see cref="BoundedContext"/> that is the source of the event</param>
/// <param name="tenant"><see cref="TenantId"/> that is related to the source of the event</param>
/// <param name="environment"><see cref="Dolittle.Execution.Environment"/> for the original <see cref="ExecutionContext"/></param>
/// <param name="claims"><see cref="Claims"/> for the user who initiated the event</param>
/// <param name="commitSequenceNumber"><see cref="CommitSequenceNumber"/> for the commit of which this event is part. May not be populated in the source Bounded Context.</param>
public OriginalContext(
Application application,
BoundedContext boundedContext,
TenantId tenant,
Dolittle.Execution.Environment environment,
Claims claims,
CommitSequenceNumber commitSequenceNumber = null)
{
Application = application;
BoundedContext = boundedContext;
Tenant = tenant;
Environment = environment;
Claims = claims;
CommitInOrigin = commitSequenceNumber ?? 0;
}
void SetOffset(EventHorizonKey key, CommitSequenceNumber commitSequenceNumber)
{
//the provider should accept the version and is responsible for transient errors and persisting it eventually
try
{
using (var repository = _getGeodesics())
{
repository.SetOffset(_eventHorizonKey, commitSequenceNumber);
}
}
catch (Exception ex)
{
_logger.Error($"Error setting offset for '{key}' : '{commitSequenceNumber}' - {ex.ToString()}");
}
}
CommittedEventStream Commit(UncommittedEventStream uncommittedEvents, CommitSequenceNumber commitSequenceNumber)
{
lock (lockObject)
{
ThrowIfDuplicate(uncommittedEvents.Id);
ThrowIfConcurrencyConflict(uncommittedEvents.Source);
var commit = new CommittedEventStream(commitSequenceNumber, uncommittedEvents.Source, uncommittedEvents.Id, uncommittedEvents.CorrelationId, uncommittedEvents.Timestamp, uncommittedEvents.Events);
_commits.Add(commit);
_duplicates.Add(commit.Id);
_versions.AddOrUpdate(commit.Source.Key, commit.Source, (id, ver) => commit.Source);
var commitsAsJson = _serializer.ToJson(_commits, SerializationOptions.CamelCase);
_jsRuntime.Invoke($"{_globalObject}.save", commitsAsJson);
_commitListeners.ForEach(_ => _.Handle(commit));
return(commit);
}
}
/// <inheritdoc />
public SingleEventTypeEventStream FetchAllEventsOfTypeAfter(ArtifactId eventType, CommitSequenceNumber commit)
{
ThrowIfDisposed();
return(_event_committer_and_fetcher.FetchAllEventsOfTypeAfter(eventType, commit));
}
/// <inheritdoc />
public Commits FetchAllCommitsAfter(CommitSequenceNumber commit)
{
return(_eventCommitterAndFetcher.FetchAllCommitsAfter(commit));
}
/// <inheritdoc />
public Commits FetchAllCommitsAfter(CommitSequenceNumber commit)
{
return(new Commits(_commits.Where(c => c.Sequence > commit).ToList()));
}
/// <inheritdoc />
public SingleEventTypeEventStream FetchAllEventsOfTypeAfter(ArtifactId artifactId, CommitSequenceNumber commitSequenceNumber)
{
var commits = _commits.Where(c => c.Sequence > commitSequenceNumber && c.Events.Any(e => e.Metadata.Artifact.Id == artifactId));
return(GetEventsFromCommits(commits, artifactId));
}
public Commits FetchAllCommitsAfter(CommitSequenceNumber commit)
{
throw new System.NotImplementedException();
}
static IEnumerable <CommittedEventEnvelope> get_events_from(ArtifactId artifactId, CommitSequenceNumber commit)
{
var committed_event_streams = processors.committed_event_streams();
var events = committed_event_streams.SelectMany(c => c.Events.Select(e => e.ToCommittedEventEnvelope(c.Sequence)))
.Where(e => e.Metadata.Artifact.Id == artifactId)
.OrderBy(c => c.Version);
return(events.Where(e => e.Version.Major >= commit).ToList());
}
/// <inheritdoc />
public SingleEventTypeEventStream FetchAllEventsOfTypeAfter(ArtifactId eventType, CommitSequenceNumber commit)
{
return(new SingleEventTypeEventStream(FetchAllEventsOfType(eventType).Where(_ => _.Version.Major >= commit)));
}
/// <inheritdoc />
public Commits FetchAllCommitsAfter(CommitSequenceNumber commit)
{
return(new Commits(FetchAllCommits().Where(_ => _.Sequence > commit)));
}
/// <inheritdoc />
public SingleEventTypeEventStream FetchAllEventsOfTypeAfter(ArtifactId eventType, CommitSequenceNumber commit)
{
return(_eventCommitterAndFetcher.FetchAllEventsOfTypeAfter(eventType, commit));
}
/// <inheritdoc />
public Commits FetchAllCommitsAfter(CommitSequenceNumber commit)
{
ThrowIfDisposed();
return(_event_committer_and_fetcher.FetchAllCommitsAfter(commit));
}
/// <summary>
/// Creates a <see cref="CommittedEventVersion" /> based upon this <see cref="VersionedEventSource" />
/// </summary>
/// <param name="commitSequence">the <see cref="CommitSequenceNumber" /></param>
/// <returns>The <see cref="CommittedEventVersion" /> based upon this <see cref="VersionedEventSource" /> </returns>
public CommittedEventVersion ToCommittedEventVersion(CommitSequenceNumber commitSequence)
{
return(this.Version.ToCommittedEventVersion(commitSequence));
}
/// <inheritdoc />
public SingleEventTypeEventStream FetchAllEventsOfTypeAfter(ArtifactId eventType, CommitSequenceNumber commit)
{
using (var es = _database.GetContext())
{
return(GetStreamFromEvents(es.Events.Where(e => e.EventArtifact == eventType && e.CommitId > (long)commit.Value).OrderBy(e => e.CommitId)));
}
}
/// <inheritdoc />
public SingleEventTypeEventStream FetchAllEventsOfTypeAfter(ArtifactId artifactId, CommitSequenceNumber commitSequenceNumber)
{
var commits = FindCommitsWithSorting(commitSequenceNumber.ToFilter() & artifactId.ToFilter());
return(GetEventsFromCommits(commits, artifactId));
}
/// <inheritdoc />
public Commits FetchAllCommitsAfter(CommitSequenceNumber commit)
{
return(GetCommits(QueryCommitsFor(_ => _.Id2 > commit.Value), $"Fetching commits after {commit.Value}"));
}
/// <inheritdoc />
public Commits FetchAllCommitsAfter(CommitSequenceNumber commit)
{
return(FindCommitsWithSorting(commit.ToFilter()));
}
/// <summary>
/// Constructs a <see cref="CommittedEventStream" /> from the <see cref="UncommittedEventStream" /> and the <see cref="CommitSequenceNumber" />
/// </summary>
/// <param name="uncommitted">the <see cref="UncommittedEventStream" /></param>
/// <param name="sequenceNumber">the <see cref="CommitSequenceNumber" /></param>
/// <returns>The corresponding <see cref="CommittedEventStream" /></returns>
public static CommittedEventStream ToCommitted(this UncommittedEventStream uncommitted, CommitSequenceNumber sequenceNumber)
{
return(new CommittedEventStream(sequenceNumber, uncommitted.Source, uncommitted.Id, uncommitted.CorrelationId, uncommitted.Timestamp, uncommitted.Events));
}
/// <summary>
/// Converts the <see cref="EventEnvelope"/> into the <see cref="CommittedEventEnvelope">Committed version</see> with the supplied <see cref="CommitSequenceNumber"/>.
/// </summary>
/// <param name="commitSequenceNumber"><see cref="CommitSequenceNumber"/> to create envelope for.</param>
/// <returns>The new <see cref="CommittedEventEnvelope" />.</returns>
public CommittedEventEnvelope ToCommittedEventEnvelope(CommitSequenceNumber commitSequenceNumber)
{
return(new CommittedEventEnvelope(commitSequenceNumber, this.Metadata, this.Event));
}
public SingleEventTypeEventStream FetchAllEventsOfTypeAfter(ArtifactId eventType, CommitSequenceNumber commit)
{
return(new SingleEventTypeEventStream(new CommittedEventEnvelope[0]));
}
/// <inheritdoc />
public SingleEventTypeEventStream FetchAllEventsOfTypeAfter(ArtifactId eventType, CommitSequenceNumber commit)
{
var sqlQuery = $"SELECT * FROM c WHERE ARRAY_CONTAINS(c.events, {{ \"event_artifact\": \"{ eventType.Value }\" }}, true) AND c.commit > {commit.Value}";
var query = QueryCommitsFor(sqlQuery);
var commits = GetCommits(query, $"Fetching events of type: {eventType} after { commit.Value }");
return(GetEventsFromCommits(commits, eventType));
}
#pragma warning restore 1591 // Xml Comments
/// <summary>
/// Creates a <see cref="CommittedEventVersion" /> based upon this <see cref="EventSourceVersion" /> and the provided <see cref="CommitSequenceNumber" />
/// </summary>
/// <param name="commitSequenceNumber">The <see cref="CommitSequenceNumber" >sequence number</see> for the commit</param>
/// <returns>The <see cref="CommittedEventVersion" /> based on this <see cref="EventSourceVersion" /></returns>
public CommittedEventVersion ToCommittedEventVersion(CommitSequenceNumber commitSequenceNumber)
{
return(new CommittedEventVersion(commitSequenceNumber, this.Commit, this.Sequence));
}
