private async Task StartProjection(Projection projection)
{
var lastCheckpoint = await _checkpointStore.GetLastCheckpoint <Position>(projection);
var settings = new CatchUpSubscriptionSettings(10000, 500, true, false, projection);
_connection.SubscribeToAllFrom(lastCheckpoint, settings, EventAppeared(projection));
}
private async Task StartProjection(Projection projection)
{
var lastCheckpoint = await checkpointStore.GetLastCheckpoint <Position>(projection);
var catchUpSubscriptionSettings = new CatchUpSubscriptionSettings(maxLiveQueueSize, readBatchSize, verboseLogging, false, projection);
eventStoreConnection.SubscribeToAllFrom(lastCheckpoint, catchUpSubscriptionSettings,
eventAppeared(projection),
liveProcessingStarted(projection), subscriptionDropped(projection), userCredentials);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_checkpoint = await _checkpointStore.GetLastCheckpoint(_checkpointId, cancellationToken);
var position = _checkpoint.Position != null
? new Position((ulong)_checkpoint.Position.Value, (ulong)_checkpoint.Position.Value)
: Position.Start;
_subscription = await _eventStoreClient.SubscribeToAllAsync(
position,
Handler,
cancellationToken : cancellationToken
);
}
public async Task StartAsync(
CancellationToken cancellationToken
) {
var checkpoint = await _checkpointStore.GetLastCheckpoint(_subscriptionId, cancellationToken);
_lastProcessedPosition = checkpoint.Position;
_subscription = await Subscribe(checkpoint, cancellationToken);
if (_measure != null) {
_cts = new CancellationTokenSource();
_measureTask = Task.Run(() => MeasureGap(_cts.Token), _cts.Token);
}
_running = true;
_log.LogInformation("Started subscription {Subscription}", _subscriptionId);
}
private async Task StartProjection(Projection projection)
{
var lastCheckpoint = await _checkpointStore.GetLastCheckpoint <Position>(projection);
var settings = new CatchUpSubscriptionSettings(
_maxLiveQueueSize,
_readBatchSize,
Log.IsTraceEnabled(),
false,
projection);
_connection.SubscribeToAllFrom(
lastCheckpoint,
settings,
EventAppeared(projection),
LiveProcessingStarted(projection),
SubscriptionDropped(projection));
}
public async Task StartAsync(CancellationToken cancellationToken)
{
if (_measure != null)
{
_cts = new CancellationTokenSource();
_measureTask = Task.Run(() => MeasureGap(_cts.Token), _cts.Token);
}
var checkpoint = await _checkpointStore.GetLastCheckpoint(SubscriptionId, cancellationToken).Ignore();
_lastProcessed = new EventPosition(checkpoint.Position, DateTime.Now);
Subscription = await Subscribe(checkpoint, cancellationToken).Ignore();
IsRunning = true;
Log?.LogInformation("Started subscription {Subscription}", SubscriptionId);
}
private async Task StartProjection(ProjectionHandler projection)
{
var projectionTypeName = projection.GetType().FullName;
Position lastCheckpoint = await _checkpointStore.GetLastCheckpoint <Position>(projectionTypeName);
var settings = new CatchUpSubscriptionSettings(
this._configurations.MaxLiveQueueSize,
this._configurations.ReadBatchSize,
false,
false,
projectionTypeName
);
_connection.SubscribeToAllFrom(
lastCheckpoint,
settings,
EventAppeared(projection, projectionTypeName),
LiveProcessingStarted(projection, projectionTypeName),
SubscriptionDropped(projection, projectionTypeName)
);
}
