// // Event data // internal static EventData GetAreaEventData( this EventStoreContext context, Event e, TimelinePosition cause, DateTimeOffset when, DateTimeOffset?whenOccurs, Id eventId, Id commandId, Id userId, FlowKey topic, Many <FlowKey> routes) { var type = context.GetEventType(e); var metadata = new AreaEventMetadata { Cause = cause, When = when, WhenOccurs = whenOccurs, CommandId = commandId, UserId = userId, Topic = topic }; metadata.ApplyRoutes(type, routes); return(new EventData( eventId.IsUnassigned ? Guid.NewGuid() : Guid.Parse(eventId.ToString()), type.ToString(), isJson: true, data: context.ToJson(e), metadata: context.ToJson(metadata))); }
internal async Task <TimelinePoint> WriteFromApp(Event e) { var eventType = _area.Events[e.GetType()]; _queryType.ExpectObserves(eventType); _currentPosition = _currentPosition.Next(); var point = new TimelinePoint( _currentPosition, TimelinePosition.None, eventType, e.When, Event.Traits.WhenOccurs.Get(e), Event.Traits.EventId.Get(e), Event.Traits.CommandId.Get(e), Event.Traits.UserId.Get(e), null, eventType.GetRoutes(e, Event.IsScheduled(e)).ToMany(), () => e); await _observer.OnNext(point); return(point); }
bool TryGetImmediateGiven(Event e, TimelinePosition position, out FlowCall.Given given) { given = null; if (TryGetObservation(e, out var observation)) { var routes = observation.EventType.GetRoutes(e).ToMany(); if (routes.Contains(Key)) { var point = new TimelinePoint( position, Point.Position, observation.EventType, e.When, Event.Traits.WhenOccurs.Get(e), Event.Traits.EventId.Get(e), Event.Traits.CommandId.Get(e), Event.Traits.UserId.Get(e), Key, routes, () => e); given = new FlowCall.Given(point, observation); } } return(given != null); }
public ResumeInfo(TimelinePosition checkpoint, Many <FlowKey> routes, Many <TimelinePoint> schedule, IConnectable subscription) { Checkpoint = checkpoint; Routes = routes; Schedule = schedule; Subscription = subscription; }
internal void OnAppended(TimelinePosition position) { lock (_updateLock) { _latestAppended = position; } }
public async Task WriteCheckpoint(Flow flow) { var result = await _context.Connection.AppendToStreamAsync( flow.Context.Key.GetCheckpointStream(), ExpectedVersion.Any, _context.GetCheckpointEventData(flow)); if (flow is Query query) { try { var checkpoint = new TimelinePosition(result.NextExpectedVersion); var etag = QueryETag.From(query.Context.Key, checkpoint).ToString(); await _context.Connection.AppendToStreamAsync( TimelineStreams.ChangedQueries, ExpectedVersion.Any, _context.GetQueryChangedEventData(new QueryChanged(etag))); } catch (Exception error) { Log.Error(error, "Failed to write QueryChanged for {Query} - subscribers will not be aware of the change until the query observes another event.", query); } } }
public async Task <QueryState> ReadState(QueryETag etag) { var stream = etag.Key.GetCheckpointStream(); var result = await _context.Connection.ReadEventAsync(stream, StreamPosition.End, resolveLinkTos : false); switch (result.Status) { case EventReadStatus.NoStream: case EventReadStatus.NotFound: return(new QueryState(etag.WithoutCheckpoint(), GetDefaultData(etag))); case EventReadStatus.Success: var number = result.Event?.Event.EventNumber; var data = result.Event?.Event.Data; var checkpoint = new TimelinePosition(number); return(checkpoint == etag.Checkpoint ? new QueryState(etag) : new QueryState(etag.WithCheckpoint(checkpoint), new MemoryStream(data))); default: throw new Exception($"Unexpected result when reading {stream}: {result.Status}"); } }
void BindFlow(TimelinePosition position) { _flow = ReadData(); FlowContext.Bind(_flow, _key, position, TimelinePosition.None); _areaCheckpoint = position.ToInt64(); }
public async Task <TimelinePosition> WriteNewEvents(TimelinePosition cause, FlowKey topicKey, Many <Event> newEvents) { var data = _context.GetNewEventData(cause, topicKey, newEvents); var result = await _context.AppendToTimeline(data); return(new TimelinePosition(result.NextExpectedVersion - newEvents.Count + 1)); }
async Task WriteNewEvents() { // EventStore was not happy when the enumerator failed - eagerly evaluate the event data var result = await _context.Connection.AppendToStreamAsync( TimelineStreams.Timeline, ExpectedVersion.Any, _context.GetNewEventData(_cause, _topicKey, _newEvents).ToMany()); _newPosition = new TimelinePosition(result.NextExpectedVersion - _newEvents.Count + 1); }
internal void ResumeWith(Many <TimelinePoint> points) { HasPoint = points.Count > 0; foreach (var point in points) { _resumeQueue.Enqueue(point); _resumeCheckpoint = point.Position; } }
public TimelineSubscription( EventStoreContext context, CatchUpSubscriptionSettings settings, TimelinePosition checkpoint, ITimelineObserver observer) { _context = context; _settings = settings; _checkpoint = checkpoint; _observer = observer; }
IEnumerable <FlowCall.Given> GetImmediateGivens(Many <Event> newEvents, TimelinePosition newPosition) { foreach (var e in newEvents) { if (TryGetImmediateGiven(e, newPosition, out var given)) { yield return(given); } newPosition = newPosition.Next(); } }
internal void OnChanged(TimelinePosition position) { lock (_updateLock) { _checkpoint = position; if (IsLatest) { _latestWait?.OnOccurred(); } } }
private TimelinePosition ConvertTimelinePosition(TimelinePosition timelineMode) { if (TimelineOrientation == TimelineOrientation.Vertical) { return(timelineMode switch { TimelinePosition.Left => RightToLeft ? TimelinePosition.End : TimelinePosition.Start, TimelinePosition.Right => RightToLeft ? TimelinePosition.Start : TimelinePosition.End, TimelinePosition.Top => TimelinePosition.Alternate, TimelinePosition.Bottom => TimelinePosition.Alternate, _ => timelineMode });
internal WriteNewEventsCommand( EventStoreContext context, TimelinePosition cause, FlowKey topicKey, Many <Event> newEvents) { _context = context; _cause = cause; _topicKey = topicKey; _newEvents = newEvents; _newEventTypes = _newEvents.ToMany(e => _context.GetEventType(e)); }
void Resume(FlowResumeInfo.Loaded info) { Flow = (T)info.Flow; lock (_queue) { foreach (var point in info.Points) { _resumeQueue.Enqueue(point); _resumeCheckpoint = point.Position; } } }
IEnumerable <FlowCall.Given> ReadImmediateGivenCalls() { for (var i = 0; i < _newEvents.Count; i++) { var e = _newEvents[i]; var type = _newEventTypes[i]; if (TryReadImmediateGiven(e, type, out var call)) { yield return(call); } _newPosition = _newPosition.Next(); } }
QueryContent GetCheckpointContent(QueryETag etag, ResolvedEvent e) { var metadata = _context.ReadCheckpointMetadata(e); if (metadata.ErrorPosition.IsSome) { throw new Exception($"Query is stopped at {metadata.ErrorPosition} with the following error: {metadata.ErrorMessage}"); } var checkpoint = new TimelinePosition(e.Event.EventNumber); return(checkpoint == etag.Checkpoint ? new QueryContent(etag) : new QueryContent(etag.WithCheckpoint(checkpoint), new MemoryStream(e.Event.Data))); }
internal static IEnumerable <EventData> GetNewEventData( this EventStoreContext context, TimelinePosition cause, FlowKey topic, Many <Event> newEvents) => from e in newEvents select context.GetAreaEventData( e, cause, e.When, Event.Traits.WhenOccurs.Get(e), Event.Traits.EventId.Get(e), Event.Traits.CommandId.Get(e), Event.Traits.UserId.Get(e), topic, context.GetEventType(e).GetRoutes(e).ToMany());
public void TimelineTest_Position(TimelineOrientation orientation, TimelinePosition position, bool rtl, string[] expectedClass) { var comp = Context.RenderComponent <TimelineTest>(p => p.AddCascadingValue(rtl)); //Console.WriteLine(comp.Markup); var timeline = comp.FindComponent <MudTimeline>(); timeline.SetParametersAndRender(p => { p.Add(x => x.TimelineOrientation, orientation); p.Add(x => x.TimelinePosition, position); }); timeline.Nodes.Should().ContainSingle(); timeline.Nodes[0].Should().BeAssignableTo <IHtmlDivElement>(); (timeline.Nodes[0] as IHtmlDivElement).ClassList.Should().Contain(expectedClass); }
public async Task <TimelinePosition> WriteNewEvents(TimelinePosition cause, FlowKey topicKey, Many <Event> newEvents) { foreach (var newEvent in newEvents) { var(copy, type) = CopyEvent(newEvent); await OnNext(new TimelinePoint( AdvancePosition(), cause, type, copy.When, Event.Traits.WhenOccurs.Get(copy), Event.Traits.EventId.Get(copy), Event.Traits.CommandId.Get(copy), Event.Traits.UserId.Get(copy), topicKey, type.GetRoutes(copy).ToMany(), () => copy)); } return(new TimelinePosition(_currentPosition.ToInt64() - newEvents.Count)); }
public Task <ImmediateGivens> WriteNewEvents(TimelinePosition cause, FlowKey topicKey, Many <Event> newEvents) => new WriteNewEventsCommand(_context, cause, topicKey, newEvents).Execute();
public Task <TimelinePosition> WriteNewEvents(TimelinePosition cause, FlowKey topicKey, Many <Event> newEvents) => throw new InvalidOperationException("New events do not occur during query tests");
bool IsAfterCheckpoint(TimelinePosition position) => (_resumeCheckpoint.IsNone || position > _resumeCheckpoint) && (Flow == null || position > Flow.Context.CheckpointPosition);
public Stopped(TimelinePosition position) { Position = position; }
public Stopped(TimelinePosition position, string error) { Position = position; Error = error; }
public static QueryETag From(FlowKey key, TimelinePosition checkpoint) => new QueryETag(key, checkpoint);
public QueryETag WithCheckpoint(TimelinePosition checkpoint) => new QueryETag(Key, checkpoint);
QueryETag(FlowKey key, TimelinePosition checkpoint) { Key = key; Checkpoint = checkpoint; }