public ProcessingStrategySelector(
ReaderSubscriptionDispatcher subscriptionDispatcher,
SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher)
{
_subscriptionDispatcher = subscriptionDispatcher;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
}
protected override IProjectionProcessingPhase CreateFirstProcessingPhase(
IPublisher publisher,
IPublisher inputQueue,
Guid projectionCorrelationId,
PartitionStateCache partitionStateCache,
Action updateStatistics,
CoreProjection coreProjection,
ReaderSubscriptionDispatcher subscriptionDispatcher,
CheckpointTag zeroCheckpointTag,
ICoreProjectionCheckpointManager checkpointManager,
IReaderStrategy readerStrategy,
IResultWriter resultWriter,
IEmittedStreamsTracker emittedStreamsTracker)
{
return(new ParallelQueryMasterProjectionProcessingPhase(
coreProjection,
projectionCorrelationId,
publisher,
inputQueue,
_projectionConfig,
updateStatistics,
_stateHandler,
partitionStateCache,
_name,
_logger,
zeroCheckpointTag,
checkpointManager,
subscriptionDispatcher,
readerStrategy,
resultWriter,
_projectionConfig.CheckpointsEnabled,
this.GetStopOnEof(),
_spoolProcessingResponseDispatcher,
emittedStreamsTracker));
}
public ProcessingStrategySelector(
ReaderSubscriptionDispatcher subscriptionDispatcher,
SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher)
{
_subscriptionDispatcher = subscriptionDispatcher;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
}
public ParallelQueryProcessingStrategy(
string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
Func <IProjectionStateHandler> handlerFactory, ProjectionConfig projectionConfig,
IQueryDefinition sourceDefinition, ProjectionNamesBuilder namesBuilder, ILogger logger,
SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(name, projectionVersion, projectionConfig, sourceDefinition, logger, subscriptionDispatcher)
{
_stateHandler = stateHandler;
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_namesBuilder = namesBuilder;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
if (_sourceDefinition.CatalogStream == SystemStreams.AllStream)
{
_catalogStreamName = SystemStreams.AllStream;
}
else if (_sourceDefinition.HasCategories())
{
_catalogStreamName = _namesBuilder.GetCategoryCatalogStreamName(_sourceDefinition.Categories[0]);
}
else
{
_catalogStreamName = _sourceDefinition.CatalogStream;
}
}
public void SetUp()
{
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher
(_bus);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionDeleted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe <ProjectionCoreServiceMessage.CoreTick>(this);
_bus.Subscribe <ReaderCoreServiceMessage.ReaderTick>(this);
AwakeService = new AwakeService();
_bus.Subscribe <StorageMessage.EventCommitted>(AwakeService);
_bus.Subscribe <StorageMessage.TfEofAtNonCommitRecord>(AwakeService);
_bus.Subscribe <AwakeServiceMessage.SubscribeAwake>(AwakeService);
_bus.Subscribe <AwakeServiceMessage.UnsubscribeAwake>(AwakeService);
_bus.Subscribe(new UnwrapEnvelopeHandler());
}
public void Setup()
{
_consumer = new TestHandler<Message>();
_bus = new InMemoryBus("temp");
_bus.Subscribe(_consumer);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
var ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_readerService = new EventReaderCoreService(_bus, ioDispatcher, 10, writerCheckpoint, runHeadingReader: true);
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(_bus);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(_bus);
_timeoutScheduler = new TimeoutScheduler();
_workerId = Guid.NewGuid();
_service = new ProjectionCoreService(
_workerId, _bus, _bus, _subscriptionDispatcher, new RealTimeProvider(), ioDispatcher,
_spoolProcessingResponseDispatcher, _timeoutScheduler);
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionDeleted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe(_spoolProcessingResponseDispatcher.CreateSubscriber<PartitionProcessingResult>());
_readerService.Handle(new Messages.ReaderCoreServiceMessage.StartReader());
_service.Handle(new ProjectionCoreServiceMessage.StartCore());
}
public void Setup()
{
_consumer = new TestHandler <Message>();
_bus = new InMemoryBus("temp");
_bus.Subscribe(_consumer);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
var ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_readerService = new EventReaderCoreService(_bus, ioDispatcher, 10, writerCheckpoint, runHeadingReader: true);
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(_bus);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(_bus);
_service = new ProjectionCoreService(
_bus, _bus, _subscriptionDispatcher, new RealTimeProvider(), ioDispatcher,
_spoolProcessingResponseDispatcher);
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe(_spoolProcessingResponseDispatcher.CreateSubscriber <PartitionProcessingResult>());
_readerService.Handle(new Messages.ReaderCoreServiceMessage.StartReader());
_service.Handle(new ProjectionCoreServiceMessage.StartCore());
}
public ParallelQueryProcessingStrategy(
string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
Func<IProjectionStateHandler> handlerFactory, ProjectionConfig projectionConfig,
IQueryDefinition sourceDefinition, ProjectionNamesBuilder namesBuilder, ILogger logger,
SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(name, projectionVersion, projectionConfig, sourceDefinition, logger, subscriptionDispatcher)
{
_stateHandler = stateHandler;
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_namesBuilder = namesBuilder;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
if (_sourceDefinition.CatalogStream == SystemStreams.AllStream)
{
_catalogStreamName = SystemStreams.AllStream;
}
else if (_sourceDefinition.HasCategories())
{
_catalogStreamName = _namesBuilder.GetCategoryCatalogStreamName(_sourceDefinition.Categories[0]);
}
else
{
_catalogStreamName = _sourceDefinition.CatalogStream;
}
}
protected EventSubscriptionBasedProjectionProcessingPhase(
IPublisher publisher, ICoreProjectionForProcessingPhase coreProjection, Guid projectionCorrelationId,
ICoreProjectionCheckpointManager checkpointManager, ProjectionConfig projectionConfig, string projectionName,
ILogger logger, CheckpointTag zeroCheckpointTag, PartitionStateCache partitionStateCache,
IResultWriter resultWriter, Action updateStatistics, ReaderSubscriptionDispatcher subscriptionDispatcher,
IReaderStrategy readerStrategy, bool useCheckpoints, bool stopOnEof)
{
_publisher = publisher;
_coreProjection = coreProjection;
_projectionCorrelationId = projectionCorrelationId;
_checkpointManager = checkpointManager;
_projectionConfig = projectionConfig;
_projectionName = projectionName;
_logger = logger;
_zeroCheckpointTag = zeroCheckpointTag;
_partitionStateCache = partitionStateCache;
_resultWriter = resultWriter;
_processingQueue = new CoreProjectionQueue(
projectionCorrelationId, publisher, projectionConfig.PendingEventsThreshold, updateStatistics);
_processingQueue.EnsureTickPending += EnsureTickPending;
_subscriptionDispatcher = subscriptionDispatcher;
_readerStrategy = readerStrategy;
_useCheckpoints = useCheckpoints;
_stopOnEof = stopOnEof;
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler<ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher
(_bus);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe(_ioDispatcher.BackwardReader);
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.Writer);
_bus.Subscribe(_ioDispatcher);
IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
_projectionConfig = new ProjectionConfig(null, 5, 10, 1000, 250, true, true, false, false, false);
var version = new ProjectionVersion(1, 0, 0);
var projectionProcessingStrategy = new ContinuousProjectionProcessingStrategy(
"projection", version, projectionStateHandler, _projectionConfig,
projectionStateHandler.GetSourceDefinition(), null, _subscriptionDispatcher);
_coreProjection = projectionProcessingStrategy.Create(
Guid.NewGuid(), _bus, SystemAccount.Principal, _bus, _ioDispatcher, _subscriptionDispatcher,
new RealTimeProvider());
_coreProjection.Start();
}
public void Setup()
{
var fakePublisher = new FakePublisher();
_ioDispatcher = new IODispatcher(fakePublisher, new PublishEnvelope(fakePublisher));
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(new FakePublisher());
}
public void SetUp()
{
_bus = new InMemoryBus("test");
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(_bus);
_testQueryDefinition = new QuerySourcesDefinition {
AllStreams = true, AllEvents = true
};
}
protected DefaultProjectionProcessingStrategy(
string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
ProjectionConfig projectionConfig, IQuerySources sourceDefinition, ILogger logger,
ReaderSubscriptionDispatcher subscriptionDispatcher, bool enableContentTypeValidation)
: base(name, projectionVersion, projectionConfig, sourceDefinition, logger, subscriptionDispatcher, enableContentTypeValidation)
{
_stateHandler = stateHandler;
}
public QueryProcessingStrategy(
string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
ProjectionConfig projectionConfig, IQuerySources sourceDefinition, ILogger logger,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(
name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, logger,
subscriptionDispatcher)
{
}
protected EventReaderBasedProjectionProcessingStrategy(
string name, ProjectionVersion projectionVersion, ProjectionConfig projectionConfig,
IQuerySources sourceDefinition, ILogger logger, ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(name, projectionVersion, logger)
{
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_subscriptionDispatcher = subscriptionDispatcher;
}
public void Setup()
{
var fakePublisher = new FakePublisher();
_ioDispatcher = new IODispatcher(fakePublisher, new PublishEnvelope(fakePublisher));
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(new FakePublisher());
}
public QueryProcessingStrategy(
string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
ProjectionConfig projectionConfig, IQuerySources sourceDefinition, ILogger logger,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(
name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, logger,
subscriptionDispatcher)
{
}
protected EventReaderBasedProjectionProcessingStrategy(
string name, ProjectionVersion projectionVersion, ProjectionConfig projectionConfig,
IQuerySources sourceDefinition, ILogger logger, ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(name, projectionVersion, logger)
{
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_subscriptionDispatcher = subscriptionDispatcher;
}
public CoreProjection Create(
Guid projectionCorrelationId,
IPublisher inputQueue,
Guid workerId,
IPrincipal runAs,
IPublisher publisher,
IODispatcher ioDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher,
ITimeProvider timeProvider)
{
if (inputQueue == null)
{
throw new ArgumentNullException("inputQueue");
}
//if (runAs == null) throw new ArgumentNullException("runAs");
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (ioDispatcher == null)
{
throw new ArgumentNullException("ioDispatcher");
}
if (timeProvider == null)
{
throw new ArgumentNullException("timeProvider");
}
var namingBuilder = new ProjectionNamesBuilder(_name, GetSourceDefinition());
var coreProjectionCheckpointWriter =
new CoreProjectionCheckpointWriter(
namingBuilder.MakeCheckpointStreamName(),
ioDispatcher,
_projectionVersion,
namingBuilder.EffectiveProjectionName);
var partitionStateCache = new PartitionStateCache();
return(new CoreProjection(
this,
_projectionVersion,
projectionCorrelationId,
inputQueue,
workerId,
runAs,
publisher,
ioDispatcher,
subscriptionDispatcher,
_logger,
namingBuilder,
coreProjectionCheckpointWriter,
partitionStateCache,
namingBuilder.EffectiveProjectionName,
timeProvider));
}
public void Setup()
{
_bus.Subscribe(_consumer);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
_readerService = new EventReaderCoreService(
GetInputQueue(), _ioDispatcher, 10, writerCheckpoint, runHeadingReader: GivenHeadingReaderRunning(),
faultOutOfOrderProjections: true);
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(GetInputQueue());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher
.CreateSubscriber <EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe <ReaderCoreServiceMessage.StartReader>(_readerService);
_bus.Subscribe <ReaderCoreServiceMessage.StopReader>(_readerService);
_bus.Subscribe <ReaderCoreServiceMessage.ReaderTick>(_readerService);
_bus.Subscribe <ReaderSubscriptionMessage.CommittedEventDistributed>(_readerService);
_bus.Subscribe <ReaderSubscriptionMessage.EventReaderEof>(_readerService);
_bus.Subscribe <ReaderSubscriptionMessage.EventReaderPartitionEof>(_readerService);
_bus.Subscribe <ReaderSubscriptionMessage.EventReaderPartitionDeleted>(_readerService);
_bus.Subscribe <ReaderSubscriptionMessage.EventReaderNotAuthorized>(_readerService);
_bus.Subscribe <ReaderSubscriptionMessage.EventReaderIdle>(_readerService);
_bus.Subscribe <ReaderSubscriptionMessage.EventReaderStarting>(_readerService);
_bus.Subscribe <ReaderSubscriptionManagement.Pause>(_readerService);
_bus.Subscribe <ReaderSubscriptionManagement.Resume>(_readerService);
_bus.Subscribe <ReaderSubscriptionManagement.Subscribe>(_readerService);
_bus.Subscribe <ReaderSubscriptionManagement.Unsubscribe>(_readerService);
_bus.Subscribe <ReaderSubscriptionManagement.SpoolStreamReadingCore>(_readerService);
_bus.Subscribe <ReaderSubscriptionManagement.CompleteSpooledStreamReading>(_readerService);
GivenAdditionalServices();
_bus.Publish(new ReaderCoreServiceMessage.StartReader(Guid.NewGuid()));
WhenLoop();
}
protected EventReaderBasedProjectionProcessingStrategy(
string name, ProjectionVersion projectionVersion, ProjectionConfig projectionConfig,
IQuerySources sourceDefinition, Serilog.ILogger logger, ReaderSubscriptionDispatcher subscriptionDispatcher, bool enableContentTypeValidation)
: base(name, projectionVersion, logger)
{
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_subscriptionDispatcher = subscriptionDispatcher;
_isBiState = sourceDefinition.IsBiState;
_enableContentTypeValidation = enableContentTypeValidation;
}
public SlaveQueryProcessingStrategy(
string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
ProjectionConfig projectionConfig, IQuerySources sourceDefinition, ILogger logger,
IPublisher resultsPublisher, Guid masterCoreProjectionId,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(
name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, logger,
subscriptionDispatcher)
{
_resultsPublisher = resultsPublisher;
_masterCoreProjectionId = masterCoreProjectionId;
}
protected override IProjectionProcessingPhase CreateFirstProcessingPhase(
IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
Action updateStatistics, CoreProjection coreProjection, ReaderSubscriptionDispatcher subscriptionDispatcher,
CheckpointTag zeroCheckpointTag, ICoreProjectionCheckpointManager checkpointManager,
IReaderStrategy readerStrategy, IResultWriter resultWriter)
{
return new ParallelQueryMasterProjectionProcessingPhase(
coreProjection, projectionCorrelationId, publisher, _projectionConfig, updateStatistics, _stateHandler,
partitionStateCache, _name, _logger, zeroCheckpointTag, checkpointManager, subscriptionDispatcher,
readerStrategy, resultWriter, _projectionConfig.CheckpointsEnabled, this.GetStopOnEof(),
_spoolProcessingResponseDispatcher);
}
public EventProcessingProjectionProcessingPhase(
CoreProjection coreProjection,
Guid projectionCorrelationId,
IPublisher publisher,
IPublisher inputQueue,
ProjectionConfig projectionConfig,
Action updateStatistics,
IProjectionStateHandler projectionStateHandler,
PartitionStateCache partitionStateCache,
bool definesStateTransform,
string projectionName,
ILogger logger,
CheckpointTag zeroCheckpointTag,
ICoreProjectionCheckpointManager coreProjectionCheckpointManager,
StatePartitionSelector statePartitionSelector,
ReaderSubscriptionDispatcher subscriptionDispatcher,
IReaderStrategy readerStrategy,
IResultWriter resultWriter,
bool useCheckpoints,
bool stopOnEof,
bool isBiState,
bool orderedPartitionProcessing,
IEmittedStreamsTracker emittedStreamsTracker,
bool enableContentTypeValidation)
: base(
publisher,
inputQueue,
coreProjection,
projectionCorrelationId,
coreProjectionCheckpointManager,
projectionConfig,
projectionName,
logger,
zeroCheckpointTag,
partitionStateCache,
resultWriter,
updateStatistics,
subscriptionDispatcher,
readerStrategy,
useCheckpoints,
stopOnEof,
orderedPartitionProcessing,
isBiState,
emittedStreamsTracker,
enableContentTypeValidation)
{
_projectionStateHandler = projectionStateHandler;
_definesStateTransform = definesStateTransform;
_statePartitionSelector = statePartitionSelector;
_isBiState = isBiState;
_stopwatch = new Stopwatch();
}
public ParallelQueryProcessingStrategy(
string name, ProjectionVersion projectionVersion, Func<IProjectionStateHandler> handlerFactory,
ProjectionConfig projectionConfig, IQueryDefinition sourceDefinition, ProjectionNamesBuilder namesBuilder,
ILogger logger, SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(name, projectionVersion, projectionConfig, sourceDefinition, logger, subscriptionDispatcher)
{
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_namesBuilder = namesBuilder;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
}
public ProjectionWorkerNode(
Guid workerId,
TFChunkDb db,
IQueuedHandler inputQueue,
ITimeProvider timeProvider,
ISingletonTimeoutScheduler timeoutScheduler,
ProjectionType runProjections,
bool faultOutOfOrderProjections)
{
_runProjections = runProjections;
Ensure.NotNull(db, "db");
_coreOutput = new InMemoryBus("Core Output");
IPublisher publisher = CoreOutput;
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(publisher);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(publisher);
_ioDispatcher = new IODispatcher(publisher, new PublishEnvelope(inputQueue));
_eventReaderCoreService = new EventReaderCoreService(
publisher,
_ioDispatcher,
10,
db.Config.WriterCheckpoint,
runHeadingReader: runProjections >= ProjectionType.System,
faultOutOfOrderProjections: faultOutOfOrderProjections);
_feedReaderService = new FeedReaderService(_subscriptionDispatcher, timeProvider);
if (runProjections >= ProjectionType.System)
{
_projectionCoreServiceCommandReader = new ProjectionCoreServiceCommandReader(
publisher,
_ioDispatcher,
workerId.ToString("N"));
var multiStreamWriter = new MultiStreamMessageWriter(_ioDispatcher);
_slaveProjectionResponseWriter = new SlaveProjectionResponseWriter(multiStreamWriter);
_projectionCoreService = new ProjectionCoreService(
workerId,
inputQueue,
publisher,
_subscriptionDispatcher,
timeProvider,
_ioDispatcher,
_spoolProcessingResponseDispatcher,
timeoutScheduler);
var responseWriter = new ResponseWriter(_ioDispatcher);
_coreResponseWriter = new ProjectionCoreResponseWriter(responseWriter);
}
}
protected abstract IProjectionProcessingPhase CreateFirstProcessingPhase(
IPublisher publisher,
IPublisher inputQueue,
Guid projectionCorrelationId,
PartitionStateCache partitionStateCache,
Action updateStatistics,
CoreProjection coreProjection,
ReaderSubscriptionDispatcher subscriptionDispatcher,
CheckpointTag zeroCheckpointTag,
ICoreProjectionCheckpointManager checkpointManager,
IReaderStrategy readerStrategy,
IResultWriter resultWriter);
public SlaveQueryProcessingStrategy(
string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
ProjectionConfig projectionConfig, IQuerySources sourceDefinition, ILogger logger,
IPublisher resultsPublisher, Guid masterCoreProjectionId,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(
name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, logger,
subscriptionDispatcher)
{
_resultsPublisher = resultsPublisher;
_masterCoreProjectionId = masterCoreProjectionId;
}
public void SetUp()
{
_bus = new InMemoryBus("test");
_consumer = new TestHandler <Message>();
_bus.Subscribe(_consumer);
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(_bus);
_testQueryDefinition = GivenQuerySource();
_feedReader = new FeedReader(
_subscriptionDispatcher, SystemAccount.Principal, _testQueryDefinition, GivenFromPosition(), 10,
Guid.NewGuid(), new PublishEnvelope(_bus), new RealTimeProvider());
Given();
When();
}
public ParallelQueryProcessingStrategy(
string name, ProjectionVersion projectionVersion, Func <IProjectionStateHandler> handlerFactory,
ProjectionConfig projectionConfig, IQueryDefinition sourceDefinition, ProjectionNamesBuilder namesBuilder,
ILogger logger, SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(name, projectionVersion, projectionConfig, sourceDefinition, logger, subscriptionDispatcher)
{
_handlerFactory = handlerFactory;
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_namesBuilder = namesBuilder;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
}
public ProjectionCoreService(
IPublisher inputQueue, IPublisher publisher, ReaderSubscriptionDispatcher subscriptionDispatcher,
ITimeProvider timeProvider, IODispatcher ioDispatcher,
SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher)
{
_inputQueue = inputQueue;
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
_subscriptionDispatcher = subscriptionDispatcher;
_timeProvider = timeProvider;
_processingStrategySelector = new ProcessingStrategySelector(
_subscriptionDispatcher, _spoolProcessingResponseDispatcher);
}
public ParallelQueryMasterProjectionProcessingPhase(
CoreProjection coreProjection, Guid projectionCorrelationId, IPublisher publisher,
ProjectionConfig projectionConfig, Action updateStatistics, PartitionStateCache partitionStateCache,
string name, ILogger logger, CheckpointTag zeroCheckpointTag,
ICoreProjectionCheckpointManager checkpointManager, ReaderSubscriptionDispatcher subscriptionDispatcher,
IReaderStrategy readerStrategy, IResultWriter resultWriter, bool checkpointsEnabled, bool stopOnEof,
SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher)
: base(
publisher, coreProjection, projectionCorrelationId, checkpointManager, projectionConfig, name, logger,
zeroCheckpointTag, partitionStateCache, resultWriter, updateStatistics, subscriptionDispatcher,
readerStrategy, checkpointsEnabled, stopOnEof)
{
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
}
public ProjectionWorkerNode(
Guid workerId,
TFChunkDb db,
QueuedHandler inputQueue,
ITimeProvider timeProvider,
ISingletonTimeoutScheduler timeoutScheduler,
ProjectionType runProjections)
{
_runProjections = runProjections;
Ensure.NotNull(db, "db");
_coreOutput = new InMemoryBus("Core Output");
IPublisher publisher = CoreOutput;
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(publisher);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(publisher);
_ioDispatcher = new IODispatcher(publisher, new PublishEnvelope(inputQueue));
_eventReaderCoreService = new EventReaderCoreService(
publisher,
_ioDispatcher,
10,
db.Config.WriterCheckpoint,
runHeadingReader: runProjections >= ProjectionType.System);
_feedReaderService = new FeedReaderService(_subscriptionDispatcher, timeProvider);
if (runProjections >= ProjectionType.System)
{
_projectionCoreServiceCommandReader = new ProjectionCoreServiceCommandReader(
publisher,
_ioDispatcher,
workerId.ToString("N"));
var multiStreamWriter = new MultiStreamMessageWriter(_ioDispatcher);
_slaveProjectionResponseWriter = new SlaveProjectionResponseWriter(multiStreamWriter);
_projectionCoreService = new ProjectionCoreService(
workerId,
inputQueue,
publisher,
_subscriptionDispatcher,
timeProvider,
_ioDispatcher,
_spoolProcessingResponseDispatcher,
timeoutScheduler);
var responseWriter = new ResponseWriter(_ioDispatcher);
_coreResponseWriter = new ProjectionCoreResponseWriter(responseWriter);
}
}
protected override IProjectionProcessingPhase CreateFirstProcessingPhase(
IPublisher publisher, Guid projectionCorrelationId, PartitionStateCache partitionStateCache,
Action updateStatistics, CoreProjection coreProjection, ReaderSubscriptionDispatcher subscriptionDispatcher,
CheckpointTag zeroCheckpointTag, ICoreProjectionCheckpointManager checkpointManager, IReaderStrategy readerStrategy, IResultWriter resultWriter)
{
var statePartitionSelector = CreateStatePartitionSelector(
_stateHandler, _sourceDefinition.ByCustomPartitions, _sourceDefinition.ByStreams);
return(new EventProcessingProjectionProcessingPhase(
coreProjection, projectionCorrelationId, publisher, _projectionConfig, updateStatistics,
_stateHandler, partitionStateCache, _sourceDefinition.DefinesStateTransform, _name, _logger,
zeroCheckpointTag, checkpointManager, statePartitionSelector, subscriptionDispatcher, readerStrategy,
resultWriter, _projectionConfig.CheckpointsEnabled, this.GetStopOnEof()));
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler <ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(_bus));
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher
(_bus);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher
.CreateSubscriber <EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionDeleted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe(_ioDispatcher.BackwardReader);
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.Writer);
_bus.Subscribe(_ioDispatcher);
IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
_projectionConfig =
new ProjectionConfig(null, 5, 10, 1000, 250, true, true, false, false, false, true, 10000, 1);
var version = new ProjectionVersion(1, 0, 0);
var projectionProcessingStrategy = new ContinuousProjectionProcessingStrategy(
"projection", version, projectionStateHandler, _projectionConfig,
projectionStateHandler.GetSourceDefinition(), null, _subscriptionDispatcher);
_coreProjection = projectionProcessingStrategy.Create(
Guid.NewGuid(),
_bus,
Guid.NewGuid(),
SystemAccount.Principal,
_bus,
_ioDispatcher,
_subscriptionDispatcher,
new RealTimeProvider());
_coreProjection.Start();
}
public void Setup()
{
_bus.Subscribe(_consumer);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
_readerService = new EventReaderCoreService(
GetInputQueue(), _ioDispatcher, 10, writerCheckpoint, runHeadingReader: GivenHeadingReaderRunning());
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(GetInputQueue());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>());
_bus.Subscribe<ReaderCoreServiceMessage.StartReader>(_readerService);
_bus.Subscribe<ReaderCoreServiceMessage.StopReader>(_readerService);
_bus.Subscribe<ReaderCoreServiceMessage.ReaderTick>(_readerService);
_bus.Subscribe<ReaderSubscriptionMessage.CommittedEventDistributed>(_readerService);
_bus.Subscribe<ReaderSubscriptionMessage.EventReaderEof>(_readerService);
_bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionEof>(_readerService);
_bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionDeleted>(_readerService);
_bus.Subscribe<ReaderSubscriptionMessage.EventReaderNotAuthorized>(_readerService);
_bus.Subscribe<ReaderSubscriptionMessage.EventReaderIdle>(_readerService);
_bus.Subscribe<ReaderSubscriptionMessage.EventReaderStarting>(_readerService);
_bus.Subscribe<ReaderSubscriptionManagement.Pause>(_readerService);
_bus.Subscribe<ReaderSubscriptionManagement.Resume>(_readerService);
_bus.Subscribe<ReaderSubscriptionManagement.Subscribe>(_readerService);
_bus.Subscribe<ReaderSubscriptionManagement.Unsubscribe>(_readerService);
_bus.Subscribe<ReaderSubscriptionManagement.SpoolStreamReadingCore>(_readerService);
_bus.Subscribe<ReaderSubscriptionManagement.CompleteSpooledStreamReading>(_readerService);
GivenAdditionalServices();
_bus.Publish(new ReaderCoreServiceMessage.StartReader());
WhenLoop();
}
protected EventSubscriptionBasedProjectionProcessingPhase(
IPublisher publisher,
IPublisher inputQueue,
ICoreProjectionForProcessingPhase coreProjection,
Guid projectionCorrelationId,
ICoreProjectionCheckpointManager checkpointManager,
ProjectionConfig projectionConfig,
string projectionName,
ILogger logger,
CheckpointTag zeroCheckpointTag,
PartitionStateCache partitionStateCache,
IResultWriter resultWriter,
Action updateStatistics,
ReaderSubscriptionDispatcher subscriptionDispatcher,
IReaderStrategy readerStrategy,
bool useCheckpoints,
bool stopOnEof,
bool orderedPartitionProcessing,
bool isBiState,
IEmittedStreamsTracker emittedStreamsTracker,
bool enableContentTypeValidation)
{
_publisher = publisher;
_inputQueue = inputQueue;
_coreProjection = coreProjection;
_projectionCorrelationId = projectionCorrelationId;
_checkpointManager = checkpointManager;
_projectionConfig = projectionConfig;
_projectionName = projectionName;
_logger = logger;
_zeroCheckpointTag = zeroCheckpointTag;
_partitionStateCache = partitionStateCache;
_resultWriter = resultWriter;
_updateStatistics = updateStatistics;
_processingQueue = new CoreProjectionQueue(publisher,
projectionConfig.PendingEventsThreshold,
orderedPartitionProcessing);
_processingQueue.EnsureTickPending += EnsureTickPending;
_subscriptionDispatcher = subscriptionDispatcher;
_readerStrategy = readerStrategy;
_useCheckpoints = useCheckpoints;
_stopOnEof = stopOnEof;
_isBiState = isBiState;
_progressResultWriter = new ProgressResultWriter(this, _resultWriter);
_inutQueueEnvelope = new PublishEnvelope(_inputQueue);
_emittedStreamsTracker = emittedStreamsTracker;
_enableContentTypeValidation = enableContentTypeValidation;
}
public void SetUp()
{
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(
_bus);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>());
}
public void SetUp()
{
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(
_bus);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionEofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.PartitionMeasured>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.SubscriptionStarted>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ReaderAssignedReader>());
}
//NOTE: this is only for slave projections (TBD)
public CoreProjection(
ProjectionProcessingStrategy projectionProcessingStrategy, ProjectionVersion version,
Guid projectionCorrelationId, IPublisher inputQueue, IPrincipal runAs, IPublisher publisher, IODispatcher ioDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher, ILogger logger, ProjectionNamesBuilder namingBuilder, CoreProjectionCheckpointWriter coreProjectionCheckpointWriter,
PartitionStateCache partitionStateCache, string effectiveProjectionName, ITimeProvider timeProvider, bool isSlaveProjection)
{
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (ioDispatcher == null)
{
throw new ArgumentNullException("ioDispatcher");
}
if (subscriptionDispatcher == null)
{
throw new ArgumentNullException("subscriptionDispatcher");
}
_projectionProcessingStrategy = projectionProcessingStrategy;
_projectionCorrelationId = projectionCorrelationId;
_inputQueue = inputQueue;
_runAs = runAs;
_name = effectiveProjectionName;
_version = version;
_stopOnEof = projectionProcessingStrategy.GetStopOnEof();
_logger = logger;
_publisher = publisher;
_partitionStateCache = partitionStateCache;
_requiresRootPartition = projectionProcessingStrategy.GetRequiresRootPartition();
_isSlaveProjection = isSlaveProjection;
var useCheckpoints = projectionProcessingStrategy.GetUseCheckpoints();
_coreProjectionCheckpointWriter = coreProjectionCheckpointWriter;
_projectionProcessingPhases = projectionProcessingStrategy.CreateProcessingPhases(
publisher, projectionCorrelationId, partitionStateCache, UpdateStatistics, this, namingBuilder,
timeProvider, ioDispatcher, coreProjectionCheckpointWriter);
//NOTE: currently assuming the first checkpoint manager to be able to load any state
_checkpointReader = new CoreProjectionCheckpointReader(
publisher, _projectionCorrelationId, ioDispatcher, namingBuilder.MakeCheckpointStreamName(), _version,
useCheckpoints);
_enrichStatistics = projectionProcessingStrategy.EnrichStatistics;
GoToState(State.Initial);
}
public ParallelQueryMasterProjectionProcessingPhase(
CoreProjection coreProjection,
Guid projectionCorrelationId,
IPublisher publisher,
IPublisher inputQueue,
ProjectionConfig projectionConfig,
Action updateStatistics,
IProjectionStateHandler stateHandler,
PartitionStateCache partitionStateCache,
string name,
ILogger logger,
CheckpointTag zeroCheckpointTag,
ICoreProjectionCheckpointManager checkpointManager,
ReaderSubscriptionDispatcher subscriptionDispatcher,
IReaderStrategy readerStrategy,
IResultWriter resultWriter,
bool checkpointsEnabled,
bool stopOnEof,
SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher,
IEmittedStreamsTracker emittedStreamsTracker)
: base(
publisher,
inputQueue,
coreProjection,
projectionCorrelationId,
checkpointManager,
projectionConfig,
name,
logger,
zeroCheckpointTag,
partitionStateCache,
resultWriter,
updateStatistics,
subscriptionDispatcher,
readerStrategy,
checkpointsEnabled,
stopOnEof,
orderedPartitionProcessing: true,
isBiState: false,
emittedStreamsTracker: emittedStreamsTracker)
{
_stateHandler = stateHandler;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
_spoolProcessingWorkItems = new Dictionary <Guid, SpoolStreamProcessingWorkItem>();
}
public ProjectionCoreService(
Guid workerId,
IPublisher inputQueue,
IPublisher publisher,
ReaderSubscriptionDispatcher subscriptionDispatcher,
ITimeProvider timeProvider,
IODispatcher ioDispatcher,
ISingletonTimeoutScheduler timeoutScheduler)
{
_workerId = workerId;
_inputQueue = inputQueue;
_publisher = publisher;
_ioDispatcher = ioDispatcher;
_timeoutScheduler = timeoutScheduler;
_subscriptionDispatcher = subscriptionDispatcher;
_timeProvider = timeProvider;
_processingStrategySelector = new ProcessingStrategySelector(_subscriptionDispatcher);
}
public EventProcessingProjectionProcessingPhase(
CoreProjection coreProjection, Guid projectionCorrelationId, IPublisher publisher,
ProjectionConfig projectionConfig, Action updateStatistics, IProjectionStateHandler projectionStateHandler,
PartitionStateCache partitionStateCache, bool definesStateTransform, string projectionName, ILogger logger,
CheckpointTag zeroCheckpointTag, ICoreProjectionCheckpointManager coreProjectionCheckpointManager,
StatePartitionSelector statePartitionSelector, ReaderSubscriptionDispatcher subscriptionDispatcher,
IReaderStrategy readerStrategy, IResultWriter resultWriter, bool useCheckpoints, bool stopOnEof)
: base(
publisher, coreProjection, projectionCorrelationId, coreProjectionCheckpointManager, projectionConfig,
projectionName, logger, zeroCheckpointTag, partitionStateCache, resultWriter, updateStatistics,
subscriptionDispatcher, readerStrategy, useCheckpoints, stopOnEof)
{
_projectionStateHandler = projectionStateHandler;
_definesStateTransform = definesStateTransform;
_statePartitionSelector = statePartitionSelector;
_stopwatch = new Stopwatch();
}
public CoreProjection Create(
Guid projectionCorrelationId,
IPublisher inputQueue,
Guid workerId,
IPrincipal runAs,
IPublisher publisher,
IODispatcher ioDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher,
ITimeProvider timeProvider)
{
if (inputQueue == null) throw new ArgumentNullException("inputQueue");
//if (runAs == null) throw new ArgumentNullException("runAs");
if (publisher == null) throw new ArgumentNullException("publisher");
if (ioDispatcher == null) throw new ArgumentNullException("ioDispatcher");
if (timeProvider == null) throw new ArgumentNullException("timeProvider");
var namingBuilder = new ProjectionNamesBuilder(_name, GetSourceDefinition());
var coreProjectionCheckpointWriter =
new CoreProjectionCheckpointWriter(
namingBuilder.MakeCheckpointStreamName(),
ioDispatcher,
_projectionVersion,
namingBuilder.EffectiveProjectionName);
var partitionStateCache = new PartitionStateCache();
return new CoreProjection(
this,
_projectionVersion,
projectionCorrelationId,
inputQueue,
workerId,
runAs,
publisher,
ioDispatcher,
subscriptionDispatcher,
_logger,
namingBuilder,
coreProjectionCheckpointWriter,
partitionStateCache,
namingBuilder.EffectiveProjectionName,
timeProvider);
}
public ProjectionWorkerNode(TFChunkDb db, QueuedHandler inputQueue, ITimeProvider timeProvider, RunProjections runProjections)
{
_runProjections = runProjections;
Ensure.NotNull(db, "db");
_coreOutput = new InMemoryBus("Core Output");
IPublisher publisher = CoreOutput;
_subscriptionDispatcher =
new ReaderSubscriptionDispatcher(publisher);
_spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(publisher);
_ioDispatcher = new IODispatcher(publisher, new PublishEnvelope(inputQueue));
_eventReaderCoreService = new EventReaderCoreService(
publisher, _ioDispatcher, 10, db.Config.WriterCheckpoint, runHeadingReader: runProjections >= RunProjections.System);
_feedReaderService = new FeedReaderService(_subscriptionDispatcher, timeProvider);
if (runProjections >= RunProjections.System)
{
_projectionCoreService = new ProjectionCoreService(
inputQueue, publisher, _subscriptionDispatcher, timeProvider, _ioDispatcher,
_spoolProcessingResponseDispatcher);
}
}
public ParallelQueryProcessingStrategy(
string name,
ProjectionVersion projectionVersion,
IProjectionStateHandler stateHandler,
ProjectionConfig projectionConfig,
IQuerySources sourceDefinition,
string handlerType,
string query,
ProjectionNamesBuilder namesBuilder,
ILogger logger,
SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher,
ReaderSubscriptionDispatcher subscriptionDispatcher)
: base(name, projectionVersion, projectionConfig, sourceDefinition, logger, subscriptionDispatcher)
{
if (string.IsNullOrEmpty(handlerType)) throw new ArgumentNullException("handlerType");
if (string.IsNullOrEmpty(query)) throw new ArgumentNullException("query");
_stateHandler = stateHandler;
_projectionConfig = projectionConfig;
_sourceDefinition = sourceDefinition;
_handlerType = handlerType;
_query = query;
_namesBuilder = namesBuilder;
_spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
if (_sourceDefinition.CatalogStream == SystemStreams.AllStream)
{
_catalogStreamName = SystemStreams.AllStream;
}
else if (_sourceDefinition.HasCategories())
{
_catalogStreamName = _namesBuilder.GetCategoryCatalogStreamName(_sourceDefinition.Categories[0]);
}
else
{
_catalogStreamName = _sourceDefinition.CatalogStream;
}
}
protected override IProjectionProcessingPhase CreateFirstProcessingPhase(
IPublisher publisher,
IPublisher inputQueue,
Guid projectionCorrelationId,
PartitionStateCache partitionStateCache,
Action updateStatistics,
CoreProjection coreProjection,
ReaderSubscriptionDispatcher subscriptionDispatcher,
CheckpointTag zeroCheckpointTag,
ICoreProjectionCheckpointManager checkpointManager,
IReaderStrategy readerStrategy,
IResultWriter resultWriter)
{
var statePartitionSelector = CreateStatePartitionSelector();
var orderedPartitionProcessing = _sourceDefinition.ByStreams && _sourceDefinition.IsBiState;
return new EventProcessingProjectionProcessingPhase(
coreProjection,
projectionCorrelationId,
publisher,
inputQueue,
_projectionConfig,
updateStatistics,
_stateHandler,
partitionStateCache,
_sourceDefinition.DefinesStateTransform,
_name,
_logger,
zeroCheckpointTag,
checkpointManager,
statePartitionSelector,
subscriptionDispatcher,
readerStrategy,
resultWriter,
_projectionConfig.CheckpointsEnabled,
this.GetStopOnEof(),
_sourceDefinition.IsBiState,
orderedPartitionProcessing: orderedPartitionProcessing);
}
public void SetUp()
{
_bus = new InMemoryBus("test");
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(_bus);
_testQueryDefinition = new QuerySourcesDefinition {AllStreams = true, AllEvents = true};
}
protected abstract IProjectionProcessingPhase CreateFirstProcessingPhase(
IPublisher publisher,
IPublisher inputQueue,
Guid projectionCorrelationId,
PartitionStateCache partitionStateCache,
Action updateStatistics,
CoreProjection coreProjection,
ReaderSubscriptionDispatcher subscriptionDispatcher,
CheckpointTag zeroCheckpointTag,
ICoreProjectionCheckpointManager checkpointManager,
IReaderStrategy readerStrategy,
IResultWriter resultWriter);
private void SetUpCoreServices(
Guid workerId,
IBus bus,
IPublisher inputQueue,
InMemoryBus output_,
ISingletonTimeoutScheduler timeoutScheduler)
{
var output = (output_ ?? inputQueue);
ICheckpoint writerCheckpoint = new InMemoryCheckpoint(1000);
var readerService = new EventReaderCoreService(
output,
_ioDispatcher,
10,
writerCheckpoint,
runHeadingReader: true);
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(inputQueue);
var spoolProcessingResponseDispatcher = new SpooledStreamReadingDispatcher(GetInputQueue());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionEofReached>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionMeasured>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.PartitionDeleted>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.SubscriptionStarted>());
bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ReaderAssignedReader>());
bus.Subscribe(spoolProcessingResponseDispatcher.CreateSubscriber<PartitionProcessingResult>());
var ioDispatcher = new IODispatcher(output, new PublishEnvelope(inputQueue));
// var coreServiceCommandReader = new ProjectionCoreServiceCommandReader(
// output,
// ioDispatcher,
// workerId.ToString("N"));
var coreService = new ProjectionCoreService(
workerId,
inputQueue,
output,
_subscriptionDispatcher,
_timeProvider,
ioDispatcher,
spoolProcessingResponseDispatcher,
timeoutScheduler);
bus.Subscribe<CoreProjectionManagementMessage.CreateAndPrepare>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.CreatePrepared>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.CreateAndPrepareSlave>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.Dispose>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.Start>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.LoadStopped>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.Stop>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.Kill>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.GetState>(coreService);
bus.Subscribe<CoreProjectionManagementMessage.GetResult>(coreService);
bus.Subscribe<CoreProjectionProcessingMessage.CheckpointCompleted>(coreService);
bus.Subscribe<CoreProjectionProcessingMessage.CheckpointLoaded>(coreService);
bus.Subscribe<CoreProjectionProcessingMessage.PrerecordedEventsLoaded>(coreService);
bus.Subscribe<CoreProjectionProcessingMessage.RestartRequested>(coreService);
bus.Subscribe<CoreProjectionProcessingMessage.Failed>(coreService);
bus.Subscribe<ClientMessage.ReadStreamEventsForwardCompleted>(ioDispatcher.ForwardReader);
bus.Subscribe<ClientMessage.ReadStreamEventsBackwardCompleted>(ioDispatcher.BackwardReader);
bus.Subscribe<ClientMessage.WriteEventsCompleted>(ioDispatcher.Writer);
bus.Subscribe<ClientMessage.DeleteStreamCompleted>(ioDispatcher.StreamDeleter);
bus.Subscribe<IODispatcherDelayedMessage>(ioDispatcher.Awaker);
bus.Subscribe<IODispatcherDelayedMessage>(ioDispatcher);
bus.Subscribe<ProjectionCoreServiceMessage.StartCore>(coreService);
bus.Subscribe<ProjectionCoreServiceMessage.StopCore>(coreService);
bus.Subscribe<ReaderCoreServiceMessage.StartReader>(readerService);
bus.Subscribe<ReaderCoreServiceMessage.StopReader>(readerService);
bus.Subscribe<ProjectionCoreServiceMessage.CoreTick>(coreService);
bus.Subscribe<ProjectionManagementMessage.SlaveProjectionsStarted>(coreService);
bus.Subscribe<ReaderCoreServiceMessage.ReaderTick>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.CommittedEventDistributed>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderEof>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionEof>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionDeleted>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderPartitionMeasured>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderNotAuthorized>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderIdle>(readerService);
bus.Subscribe<ReaderSubscriptionMessage.EventReaderStarting>(readerService);
bus.Subscribe<ReaderSubscriptionManagement.Pause>(readerService);
bus.Subscribe<ReaderSubscriptionManagement.Resume>(readerService);
bus.Subscribe<ReaderSubscriptionManagement.Subscribe>(readerService);
bus.Subscribe<ReaderSubscriptionManagement.Unsubscribe>(readerService);
bus.Subscribe<ReaderSubscriptionManagement.SpoolStreamReadingCore>(readerService);
bus.Subscribe<ReaderSubscriptionManagement.CompleteSpooledStreamReading>(readerService);
if (output_ != null)
{
bus.Subscribe(new UnwrapEnvelopeHandler());
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.StateReport>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.ResultReport>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.StatisticsReport>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.Started>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.Stopped>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.Faulted>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.Prepared>(GetInputQueue()));
output_.Subscribe(
Forwarder.Create<CoreProjectionManagementMessage.SlaveProjectionReaderAssigned>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<CoreProjectionStatusMessage.ProjectionWorkerStarted>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<ProjectionManagementMessage.Command.ControlMessage>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<AwakeServiceMessage.SubscribeAwake>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<AwakeServiceMessage.UnsubscribeAwake>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<PartitionProcessingResultBase>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<ReaderSubscriptionManagement.SpoolStreamReading>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<PartitionProcessingResultOutputBase>(GetInputQueue()));
output_.Subscribe(Forwarder.Create<Message>(inputQueue)); // forward all
var forwarder = new RequestResponseQueueForwarder(
inputQueue: inputQueue,
externalRequestQueue: GetInputQueue());
// forwarded messages
output_.Subscribe<ClientMessage.ReadEvent>(forwarder);
output_.Subscribe<ClientMessage.ReadStreamEventsBackward>(forwarder);
output_.Subscribe<ClientMessage.ReadStreamEventsForward>(forwarder);
output_.Subscribe<ClientMessage.ReadAllEventsForward>(forwarder);
output_.Subscribe<ClientMessage.WriteEvents>(forwarder);
}
}
public void SetUp()
{
_bus = new InMemoryBus("test");
_consumer = new TestHandler<Message>();
_bus.Subscribe(_consumer);
_subscriptionDispatcher = new ReaderSubscriptionDispatcher(_bus);
_testQueryDefinition = GivenQuerySource();
_feedReader = new FeedReader(
_subscriptionDispatcher, SystemAccount.Principal, _testQueryDefinition, GivenFromPosition(), 10,
Guid.NewGuid(), new PublishEnvelope(_bus), new RealTimeProvider());
Given();
When();
}
