public async Task Start(CancellationToken cancellationToken) { foreach (var projection in _registeredProjections.Projections) { await projection.UpdateUserDesiredState(UserDesiredState.Started, cancellationToken); } _commandBus.Queue <StartAll>(); }
private Task OnStreamMessageReceived( IAllStreamSubscription subscription, StreamMessage message, CancellationToken cancellationToken) { _commandBus.Queue(new ProcessStreamEvent(message, cancellationToken)); return(Task.CompletedTask); }
private void CatchUpStopped(CatchUpStopReason reason) { var message = "Stopping catch up {RunnerName}: {Reason}"; if (reason == CatchUpStopReason.Error) { _logger.LogWarning(message, _runnerName, reason); } else { _logger.LogInformation(message, _runnerName, reason); } _commandBus.Queue(new RemoveStoppedCatchUp(_runnerName)); if (CatchUpStopReason.Finished == reason) { _commandBus.Queue(new Subscribe(_runnerName)); } }
private async Task StartStream() { if (_streamsStoreSubscription.StreamIsRunning) { return; } if (_handlers.Count > 0) { var staleSubscriptions = _handlers.Keys.ToReadOnlyList(); _logger.LogInformation("Remove stale subscriptions before starting stream: {subscriptions}", staleSubscriptions.ToString(", ")); _handlers.Clear(); foreach (var name in staleSubscriptions) { _commandBus.Queue(new Start(name)); } } _lastProcessedMessagePosition = await _streamsStoreSubscription.Start(); }
public async Task Handle(ConnectedProjectionCommand?command) { if (command == null) { _logger.LogWarning("Skipping null Command"); return; } switch (command) { case SubscriptionCommand subscriptionCommand: await _subscriptionRunner.HandleSubscriptionCommand(subscriptionCommand); return; case CatchUpCommand catchUpCommand: _catchUpRunner.HandleCatchUpCommand(catchUpCommand); return; } _logger.LogTrace("Handling {Command}", command); switch (command) { case Start start: _commandBus.Queue(new Subscribe(start.Projection)); break; case StartAll _: _commandBus.Queue <SubscribeAll>(); break; case Stop stop: _commandBus.Queue(new StopCatchUp(stop.Projection)); _commandBus.Queue(new Unsubscribe(stop.Projection)); break; case StopAll _: _commandBus.Queue <StopAllCatchUps>(); _commandBus.Queue <UnsubscribeAll>(); break; case Restart restart: await Task.Delay(restart.After); _commandBus.Queue(new Start(restart.Projection)); break; default: _logger.LogError("No handler defined for {Command}", command); break; } }
public async Task Handle(ConnectedProjectionCommand command) { switch (command) { case SubscriptionCommand subscriptionCommand: await _subscriptionRunner.HandleSubscriptionCommand(subscriptionCommand); return; case CatchUpCommand catchUpCommand: _catchUpRunner.HandleCatchUpCommand(catchUpCommand); return; } _logger.LogTrace("Handling {Command}", command); switch (command) { case Start start: _commandBus.Queue(new Subscribe(start.ProjectionName)); break; case StartAll _: _commandBus.Queue <SubscribeAll>(); break; case Stop stop: _commandBus.Queue(new StopCatchUp(stop.ProjectionName)); _commandBus.Queue(new Unsubscribe(stop.ProjectionName)); break; case StopAll _: _commandBus.Queue <StopAllCatchUps>(); _commandBus.Queue <UnsubscribeAll>(); break; default: _logger.LogError("No handler defined for {Command}", command); break; } }
public static void Queue <TCommand>(this IConnectedProjectionsCommandBus commandBus) where TCommand : ConnectedProjectionCommand, new() => commandBus?.Queue(new TCommand());
public void Start() => _commandBus.Queue <StartAll>();
public async Task CatchUpAsync(CancellationToken cancellationToken) { cancellationToken.Register(() => CatchUpStopped(CatchUpStopReason.Aborted)); try { if (cancellationToken.IsCancellationRequested) { return; } _logger.LogDebug( "Started catch up with paging (CatchUpPageSize: {CatchUpPageSize})", _settings.CatchUpPageSize); long?position; using (var context = _projection.ContextFactory()) position = await context.Value.GetProjectionPosition(_projection.Id, cancellationToken); if (cancellationToken.IsCancellationRequested) { return; } _logger.LogInformation( "Start catch up {Projection} at {Position}", _projection.Id, position); var page = await ReadPages(_streamStore, position, cancellationToken); var continueProcessing = cancellationToken.IsCancellationRequested == false; while (continueProcessing) { _logger.LogDebug( "Processing page of {PageSize} starting at POS {FromPosition}", page.Messages.Length, page.FromPosition); await _projection .ConnectedProjectionMessageHandler .HandleAsync( page.Messages, _catchUpStreamGapStrategy, cancellationToken); if (cancellationToken.IsCancellationRequested) { return; } if (page.IsEnd) { continueProcessing = false; } else { page = await page.ReadNext(cancellationToken); } } CatchUpStopped(CatchUpStopReason.Finished); } catch (TaskCanceledException) { } catch (ConnectedProjectionMessageHandlingException e) when(e.InnerException is StreamGapDetectedException) { var projection = e.Projection; var delayInSeconds = _catchUpStreamGapStrategy.Settings.RetryDelayInSeconds; _logger.LogWarning( "Detected gap in the message stream for catching up projection. Aborted projection {Projection} and queued restart in {GapStrategySettings.RetryDelayInSeconds} seconds.", projection, delayInSeconds); CatchUpStopped(CatchUpStopReason.Aborted); _commandBus.Queue( new Restart( projection, TimeSpan.FromSeconds(delayInSeconds))); } catch (ConnectedProjectionMessageHandlingException exception) { _logger.LogError( exception.InnerException, "{Projection} catching up failed because an exception was thrown when handling the message at {Position}.", exception.Projection, exception.RunnerPosition); CatchUpStopped(CatchUpStopReason.Error); } catch (Exception exception) { _logger.LogError( exception, "{Projection} catching up failed because an exception was thrown", _projection.Id); CatchUpStopped(CatchUpStopReason.Error); } }