private void OnEvent(RecordedEvent recordedEvent, Position position)
{
if (Event != null)
{
Event(this, new RecordedEventEventArgs(recordedEvent));
}
}
public void Save(Position position)
{
var lastProcessedPosition = new LastProcessedPosition
{
CommitPosition = position.CommitPosition,
PreparePosition = position.PreparePosition
};
collection.Save(lastProcessedPosition);
}
public void Start()
{
ViewBuilderData mainData;
using (var session = _store.OpenSession())
{
mainData = session.Load<ViewBuilderData>("main");
}
Position pos = Position.Start;
if (mainData != null)
{
pos = new Position(mainData.CommitPosition, mainData.PreparePosition);
}
_subscription = _eventStoreConnection.SubscribeToAllFrom(
pos, false, HandleEvent);
}
internal static Position? ParsePosition(this string checkpointToken)
{
var position = default(Position?);
if(checkpointToken != null)
{
var positions = checkpointToken.Split(new[] {'/'}, 2).Select(s => s.Trim()).ToArray();
if(positions.Length != 2)
{
throw new ArgumentException();
}
position = new Position(long.Parse(positions[0]), long.Parse(positions[1]));
}
return position;
}
internal AllEventsSlice(ReadDirection readDirection, Position fromPosition, Position nextPosition, ClientMessage.ResolvedEvent[] events)
{
ReadDirection = readDirection;
FromPosition = fromPosition;
NextPosition = nextPosition;
if (events == null)
Events = EmptyEvents;
else
{
Events = new ResolvedEvent[events.Length];
for (int i = 0; i < Events.Length; ++i)
{
Events[i] = new ResolvedEvent(events[i]);
}
}
}
public void Start()
{
Init();
Position current;
_accessor.Read(0, out current);
var mre = new ManualResetEventSlim(false);
var _lastRead = Enumerable.Empty<RecordedEvent>();
_eventStoreConnection.SubscribeToAllStreamsAsync((ev, pos) =>
{
if (!mre.IsSet)
mre.Wait();
_accessor.Read(0, out current);
if (current.Commit > pos.CommitPosition)
return;
Publish(new[] { ev });
}, () =>
{
// dropped, refresh
});
_eventStoreConnection.ReadAllEventsForwardAsync(new ClientAPI.Position(current.Commit, current.Prepare), _batch)
.ContinueWith(s =>
{
Publish(s.Result.Events);
_lastRead = s.Result.Events;
int lastCount = current.Count;
current = new Position
{
Prepare = s.Result.Position.PreparePosition,
Commit = s.Result.Position.CommitPosition,
Count = lastCount + s.Result.Events.Count()
};
_accessor.Write(0, ref current);
mre.Set();
}).Wait();
}
public void Save(String endpoint, EventStore.ClientAPI.Position position)
{
using (var session = _store.OpenSession())
{
var db = session.Load <Position>(endpoint);
if (db == null)
{
db = new Position {
Id = endpoint
};
session.Store(db);
}
db.CommitPosition = position.CommitPosition;
db.PreparePosition = position.PreparePosition;
session.SaveChanges();
}
}
public EventStoreAllCatchUpSubscription SubscribeToAllFrom(
Position? fromPositionExclusive,
bool resolveLinkTos,
Action<EventStoreCatchUpSubscription, ResolvedEvent> eventAppeared,
Action<EventStoreCatchUpSubscription> liveProcessingStarted = null,
Action<EventStoreCatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped = null,
UserCredentials userCredentials = null,
int readBatchSize = 500)
{
Ensure.NotNull(eventAppeared, "eventAppeared");
var catchUpSubscription =
new EventStoreAllCatchUpSubscription(this, _settings.Log, fromPositionExclusive, resolveLinkTos,
userCredentials, eventAppeared, liveProcessingStarted,
subscriptionDropped, _settings.VerboseLogging, readBatchSize);
catchUpSubscription.Start();
return catchUpSubscription;
}
public Task<AllEventsSlice> ReadAllEventsBackwardAsync(Position position, int maxCount, bool resolveLinkTos, UserCredentials userCredentials = null)
{
Ensure.Positive(maxCount, "maxCount");
var source = new TaskCompletionSource<AllEventsSlice>();
var operation = new ReadAllEventsBackwardOperation(_settings.Log, source, position, maxCount,
resolveLinkTos, _settings.RequireMaster, userCredentials);
EnqueueOperation(operation);
return source.Task;
}
public AllEventsSlice ReadAllEventsBackward(Position position, int maxCount, bool resolveLinkTos, UserCredentials userCredentials = null)
{
return ReadAllEventsBackwardAsync(position, maxCount, resolveLinkTos, userCredentials).Result;
}
private EventStoreCatchUpSubscription SubscribeToAllFrom(Position? lastCheckpoint)
{
return _eventStore.SubscribeToAllFrom(lastCheckpoint,
false,
EventAppeared,
_ => _onCaughtUp(),
SubscriptionDropped,
_userCredentials);
}
public EventStoreAllCatchUpSubscription SubscribeToAllFrom(
Position? lastCheckpoint,
CatchUpSubscriptionSettings settings,
Action<EventStoreCatchUpSubscription, ResolvedEvent> eventAppeared,
Action<EventStoreCatchUpSubscription> liveProcessingStarted = null,
Action<EventStoreCatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped = null,
UserCredentials userCredentials = null)
{
throw new NotImplementedException();
}
internal EventStoreAllCatchUpSubscription(IEventStoreConnection connection,
ILogger log,
Position? fromPositionExclusive, /* if null -- from the very beginning */
UserCredentials userCredentials,
Action<EventStoreCatchUpSubscription, ResolvedEvent> eventAppeared,
Action<EventStoreCatchUpSubscription> liveProcessingStarted,
Action<EventStoreCatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped,
CatchUpSubscriptionSettings settings)
: base(connection, log, string.Empty, userCredentials,
eventAppeared, liveProcessingStarted, subscriptionDropped, settings)
{
_lastProcessedPosition = fromPositionExclusive ?? new Position(-1, -1);
_nextReadPosition = fromPositionExclusive ?? Position.Start;
}
public RavenOperation(Action<IDocumentSession> execute, Position position)
{
Execute = execute;
Position = position;
}
public Task<AllEventsSlice> ReadAllEventsBackwardAsync(Position position, int maxCount, bool resolveLinkTos, UserCredentials userCredentials = null)
{
return _conn.ReadAllEventsBackwardAsync(position, maxCount, resolveLinkTos, userCredentials);
}
public AllEventsSlice ReadAllEventsForward(Position position, int maxCount, bool resolveLinkTos, UserCredentials userCredentials = null)
{
return _conn.ReadAllEventsForward(position, maxCount, resolveLinkTos, userCredentials);
}
internal EventStoreAllCatchUpSubscription(IEventStoreConnection connection,
ILogger log,
Position? fromPositionExclusive, /* if null -- from the very beginning */
bool resolveLinkTos,
UserCredentials userCredentials,
Action<EventStoreCatchUpSubscription, ResolvedEvent> eventAppeared,
Action<EventStoreCatchUpSubscription> liveProcessingStarted,
Action<EventStoreCatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped,
bool verboseLogging,
int readBatchSize = 500)
: base(connection, log, string.Empty, resolveLinkTos, userCredentials,
eventAppeared, liveProcessingStarted, subscriptionDropped, verboseLogging, readBatchSize)
{
_lastProcessedPosition = fromPositionExclusive ?? new Position(-1, -1);
_nextReadPosition = fromPositionExclusive ?? Position.Start;
}
/// <summary>
/// Compares this instance of <see cref="Position" /> for equality
/// with another instance.
/// </summary>
/// <param name="other">A <see cref="Position" /></param>
/// <returns>True if this instance is equal to the other instance.</returns>
public bool Equals(Position other)
{
return this == other;
}
public IEnumerable<object> ReadSlice()
{
var slice = connection.ReadAllEventsForward(currentPosition, SliceSize);
currentPosition = slice.Position;
return slice.Events;
}
public AllEventStreamsPullSource(EventStoreConnection connection, Position startFrom)
{
this.connection = connection;
currentPosition = startFrom;
}
/// <summary>
/// Reads All Events in the node backwards (e.g. end to beginning)
/// </summary>
/// <param name="position">The position to start reading from</param>
/// <param name="maxCount">The maximum count to read</param>
/// <param name="resolveLinkTos">Whether to resolve LinkTo events automatically</param>
/// <returns>A <see cref="AllEventsSlice"/> containing the records read</returns>
public AllEventsSlice ReadAllEventsBackward(Position position, int maxCount, bool resolveLinkTos)
{
return ReadAllEventsBackwardAsync(position, maxCount, resolveLinkTos).Result;
}
/// <summary>
/// Reads All Events in the node backwards (e.g. end to beginning)
/// </summary>
/// <param name="position">The position to start reading from</param>
/// <param name="maxCount">The maximum count to read</param>
/// <param name="resolveLinkTos">Whether to resolve LinkTo events automatically</param>
/// <returns>A <see cref="AllEventsSlice"/> containing the records read</returns>
public Task<AllEventsSlice> ReadAllEventsBackwardAsync(Position position, int maxCount, bool resolveLinkTos)
{
Ensure.Positive(maxCount, "maxCount");
EnsureActive();
var source = new TaskCompletionSource<AllEventsSlice>();
var operation = new ReadAllEventsBackwardOperation(source, Guid.NewGuid(), position, maxCount, resolveLinkTos);
EnqueueOperation(operation);
return source.Task;
}
public EventStoreAllCatchUpSubscription SubscribeToAllFrom(
Position? fromPositionExclusive,
bool resolveLinkTos,
Action<EventStoreCatchUpSubscription, ResolvedEvent> eventAppeared,
Action<EventStoreCatchUpSubscription> liveProcessingStarted = null,
Action<EventStoreCatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped = null,
UserCredentials userCredentials = null)
{
return _conn.SubscribeToAllFrom(fromPositionExclusive, resolveLinkTos,
eventAppeared, liveProcessingStarted, subscriptionDropped, userCredentials);
}
protected override void ReadEventsTill(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long? lastCommitPosition, int? lastEventNumber)
{
bool done;
do
{
AllEventsSlice slice = connection.ReadAllEventsForward(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials);
foreach (var e in slice.Events)
{
if (e.OriginalPosition == null) throw new Exception("Subscription event came up with no OriginalPosition.");
TryProcess(e);
}
_nextReadPosition = slice.NextPosition;
done = lastCommitPosition == null
? slice.IsEndOfStream
: slice.NextPosition >= new Position(lastCommitPosition.Value, lastCommitPosition.Value);
if (!done && slice.IsEndOfStream)
Thread.Sleep(1); // we are waiting for server to flush its data
} while (!done);
if (Verbose)
Log.Debug("Catch-up Subscription to {0}: finished reading events, nextReadPosition = {1}.",
IsSubscribedToAll ? "<all>" : StreamId, _nextReadPosition);
}
/// <summary>
/// Try to process a single <see cref="ResolvedEvent"/>.
/// </summary>
/// <param name="e">The <see cref="ResolvedEvent"/> to process.</param>
protected override void TryProcess(ResolvedEvent e)
{
bool processed = false;
if (e.OriginalPosition > _lastProcessedPosition)
{
EventAppeared(this, e);
_lastProcessedPosition = e.OriginalPosition.Value;
processed = true;
}
if (Verbose)
Log.Debug("Catch-up Subscription to {0}: {1} event ({2}, {3}, {4} @ {5}).",
IsSubscribedToAll ? "<all>" : StreamId, processed ? "processed" : "skipping",
e.OriginalEvent.EventStreamId, e.OriginalEvent.EventNumber, e.OriginalEvent.EventType, e.OriginalPosition);
}
private bool ProcessEvents(long? lastCommitPosition, AllEventsSlice slice)
{
foreach (var e in slice.Events)
{
if (e.OriginalPosition == null) throw new Exception("Subscription event came up with no OriginalPosition.");
TryProcess(e);
}
_nextReadPosition = slice.NextPosition;
var done = lastCommitPosition == null
? slice.IsEndOfStream
: slice.NextPosition >= new Position(lastCommitPosition.Value, lastCommitPosition.Value);
if (!done && slice.IsEndOfStream)
Thread.Sleep(1); // we are waiting for server to flush its data
return done;
}
public Task<AllEventsSlice> ReadAllEventsBackwardAsync(Position position, int maxCount, bool resolveLinkTos,
UserCredentials userCredentials = null)
{
throw new NotImplementedException();
}
public Subject<ResolvedEvent> SubscribeToAllFrom(Position? position)
{
this.connection.SubscribeToAllFrom(position, false, (s, e) => events.OnNext(e), null, HandleSubscriptionDropped, null);
return events;
}
private async Task WriteCheckpoint(Position? checkpoint)
{
await AppendToStream("checkpoints",
ExpectedVersion.Any,
new CheckpointReached
{
CheckpointToken = checkpoint.ToCheckpointToken(),
CorrelationId = _correlationId,
ProcessId =
ProcessHandler<OrderFulfillment, CompareablePosition>.DefaultBuildProcessManagerId(
_correlationId)
});
}
private void Init()
{
if (!File.Exists(_fileName))
{
_file = MemoryMappedFile.CreateNew(_fileName, 4096);
_accessor = _file.CreateViewAccessor();
var begin = new Position();
_accessor.Write(0, ref begin);
}
else
{
_file = MemoryMappedFile.CreateOrOpen(_fileName, 4096);
_accessor = _file.CreateViewAccessor();
}
while (true)
{
Position current;
_accessor.Read(0, out current);
var _lastRead = Enumerable.Empty<RecordedEvent>();
_eventStoreConnection.ReadAllEventsForwardAsync(new ClientAPI.Position(current.Commit, current.Prepare), _batch)
.ContinueWith(s =>
{
Publish(s.Result.Events);
_lastRead = s.Result.Events;
int lastCount = current.Count;
current = new Position
{
Prepare = s.Result.Position.PreparePosition,
Commit = s.Result.Position.CommitPosition,
Count = lastCount + s.Result.Events.Count()
};
_accessor.Write(0, ref current);
}).Wait();
if (_lastRead.Count() < _batch)
break;
}
}
public static AllEventsSlice ReadAllEventsForward(this IEventStoreConnection con, Position position, int maxCount, bool resolveLinkTos, UserCredentials userCredentials = null)
{
var task = con.ReadAllEventsForwardAsync(position, maxCount, resolveLinkTos, userCredentials);
task.Wait();
return task.Result;
}
