public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler <ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher = new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_subscriptionDispatcher =
new PublishSubscribeDispatcher
<ReaderSubscriptionManagement.Subscribe,
ReaderSubscriptionManagement.ReaderSubscriptionManagementMessage, EventReaderSubscriptionMessage>
(_bus, v => v.SubscriptionId, v => v.SubscriptionId);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber <EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
_projectionConfig = new ProjectionConfig(null, 5, 10, 1000, 250, true, true, false, false);
_coreProjection = CoreProjection.CreateAndPrepare(
"projection", new ProjectionVersion(1, 0, 0), Guid.NewGuid(), _bus, projectionStateHandler, _projectionConfig, _readDispatcher,
_writeDispatcher, _subscriptionDispatcher, null, new RealTimeProvider());
_coreProjection.Start();
}
public ICoreProjectionCheckpointManager CreateCheckpointManager(
Guid projectionCorrelationId, ProjectionVersion projectionVersion, IPublisher publisher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, ProjectionNamesBuilder namingBuilder)
{
var emitAny = projectionConfig.EmitEventEnabled;
var emitPartitionCheckpoints = UseCheckpoints && (_byCustomPartitions || _byStream);
var resultEmitter = _definesStateTransform
? new ResultEmitter(namingBuilder)
: (IResultEmitter) new NoopResultEmitter();
//NOTE: not emitting one-time/transient projections are always handled by default checkpoint manager
// as they don't depend on stable event order
if (emitAny && !ReaderStrategy.IsReadingOrderRepeatable)
{
return(new MultiStreamMultiOutputCheckpointManager(
publisher, projectionCorrelationId, projectionVersion, _runAs, readDispatcher, writeDispatcher,
projectionConfig, name, ReaderStrategy.PositionTagger, namingBuilder, resultEmitter, UseCheckpoints,
emitPartitionCheckpoints));
}
else
{
return(new DefaultCheckpointManager(
publisher, projectionCorrelationId, projectionVersion, _runAs, readDispatcher, writeDispatcher,
projectionConfig, name, ReaderStrategy.PositionTagger, namingBuilder, resultEmitter, UseCheckpoints,
emitPartitionCheckpoints));
}
}
public ManagedProjection(
IPublisher coreQueue,
Guid id, string name, ILogger logger,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
RequestResponseDispatcher <ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>
readDispatcher, IPublisher inputQueue, ProjectionStateHandlerFactory projectionStateHandlerFactory)
{
if (id == Guid.Empty)
{
throw new ArgumentException("id");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name == "")
{
throw new ArgumentException("name");
}
_coreQueue = coreQueue;
_id = id;
_name = name;
_logger = logger;
_writeDispatcher = writeDispatcher;
_readDispatcher = readDispatcher;
_inputQueue = inputQueue;
_projectionStateHandlerFactory = projectionStateHandlerFactory;
}
public ProjectionCheckpoint(
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionVersion projectionVersion, IPrincipal runAs, IProjectionCheckpointManager readyHandler,
CheckpointTag from, PositionTagger positionTagger, CheckpointTag zero, int maxWriteBatchLength,
ILogger logger = null)
{
if (readDispatcher == null) throw new ArgumentNullException("readDispatcher");
if (writeDispatcher == null) throw new ArgumentNullException("writeDispatcher");
if (readyHandler == null) throw new ArgumentNullException("readyHandler");
if (positionTagger == null) throw new ArgumentNullException("positionTagger");
if (zero == null) throw new ArgumentNullException("zero");
if (from.CommitPosition <= from.PreparePosition) throw new ArgumentException("from");
//NOTE: fromCommit can be equal fromPrepare on 0 position. Is it possible anytime later? Ignoring for now.
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
_projectionVersion = projectionVersion;
_runAs = runAs;
_readyHandler = readyHandler;
_positionTagger = positionTagger;
_zero = zero;
_from = _last = from;
_maxWriteBatchLength = maxWriteBatchLength;
_logger = logger;
}
public DefaultCheckpointManager(
IPublisher publisher, Guid projectionCorrelationId, ProjectionVersion projectionVersion, IPrincipal runAs,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, PositionTagger positionTagger,
ProjectionNamesBuilder namingBuilder, IResultEmitter resultEmitter, bool useCheckpoints,
bool emitPartitionCheckpoints = false)
: base(
publisher, projectionCorrelationId, projectionConfig, name, positionTagger, namingBuilder, resultEmitter,
useCheckpoints, emitPartitionCheckpoints)
{
if (readDispatcher == null)
{
throw new ArgumentNullException("readDispatcher");
}
if (writeDispatcher == null)
{
throw new ArgumentNullException("writeDispatcher");
}
_projectionVersion = projectionVersion;
_runAs = runAs;
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
_positionTagger = positionTagger;
_projectionCheckpointStreamId = namingBuilder.MakeCheckpointStreamName();
_zeroTag = positionTagger.MakeZeroCheckpointTag();
}
public ICoreProjectionCheckpointManager CreateCheckpointManager(
ICoreProjection coreProjection, Guid projectionCorrelationId, IPublisher publisher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>
requestResponseDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> responseDispatcher,
ProjectionConfig projectionConfig, string name, string stateUpdatesStreamId)
{
if (_allStreams && _useEventIndexes && _events != null && _events.Count > 1)
{
string projectionStateUpdatesStreamId = stateUpdatesStreamId;
return(new MultiStreamCheckpointManager(
coreProjection, publisher, projectionCorrelationId, requestResponseDispatcher, responseDispatcher,
projectionConfig, name, PositionTagger, projectionStateUpdatesStreamId));
}
else if (_streams != null && _streams.Count > 1)
{
string projectionStateUpdatesStreamId = stateUpdatesStreamId;
return(new MultiStreamCheckpointManager(
coreProjection, publisher, projectionCorrelationId, requestResponseDispatcher, responseDispatcher,
projectionConfig, name, PositionTagger, projectionStateUpdatesStreamId));
}
else
{
string projectionCheckpointStreamId = CoreProjection.ProjectionsStreamPrefix + name
+ CoreProjection.ProjectionCheckpointStreamSuffix;
return(new DefaultCheckpointManager(
coreProjection, publisher, projectionCorrelationId, requestResponseDispatcher, responseDispatcher,
projectionConfig, projectionCheckpointStreamId, name, PositionTagger));
}
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler<ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher = new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_subscriptionDispatcher =
new PublishSubscribeDispatcher
<ReaderSubscriptionManagement.Subscribe,
ReaderSubscriptionManagement.ReaderSubscriptionManagementMessage, EventReaderSubscriptionMessage>
(_bus, v => v.SubscriptionId, v => v.SubscriptionId);
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CommittedEventReceived>());
_bus.Subscribe(
_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.CheckpointSuggested>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.EofReached>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.ProgressChanged>());
_bus.Subscribe(_subscriptionDispatcher.CreateSubscriber<EventReaderSubscriptionMessage.NotAuthorized>());
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
_projectionConfig = new ProjectionConfig(null, 5, 10, 1000, 250, true, true, false, false);
_coreProjection = CoreProjection.CreateAndPrepare(
"projection", new ProjectionVersion(1, 0, 0), Guid.NewGuid(), _bus, projectionStateHandler, _projectionConfig, _readDispatcher,
_writeDispatcher, _subscriptionDispatcher, null, new RealTimeProvider());
_coreProjection.Start();
}
protected CoreProjectionCheckpointManager(
ICoreProjection coreProjection, IPublisher publisher, Guid projectionCorrelationId,
RequestResponseDispatcher<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, PositionTagger positionTagger,
ProjectionNamesBuilder namingBuilder, bool useCheckpoints, bool emitStateUpdated,
bool emitPartitionCheckpoints)
{
if (coreProjection == null) throw new ArgumentNullException("coreProjection");
if (publisher == null) throw new ArgumentNullException("publisher");
if (readDispatcher == null) throw new ArgumentNullException("readDispatcher");
if (writeDispatcher == null) throw new ArgumentNullException("writeDispatcher");
if (projectionConfig == null) throw new ArgumentNullException("projectionConfig");
if (name == null) throw new ArgumentNullException("name");
if (positionTagger == null) throw new ArgumentNullException("positionTagger");
if (namingBuilder == null) throw new ArgumentNullException("namingBuilder");
if (name == "") throw new ArgumentException("name");
if (emitPartitionCheckpoints && emitStateUpdated)
throw new InvalidOperationException("EmitPartitionCheckpoints && EmitStateUpdated cannot be both set");
_lastProcessedEventPosition = new PositionTracker(positionTagger);
_coreProjection = coreProjection;
_publisher = publisher;
_projectionCorrelationId = projectionCorrelationId;
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
_projectionConfig = projectionConfig;
_logger = LogManager.GetLoggerFor<CoreProjectionCheckpointManager>();
_name = name;
_positionTagger = positionTagger;
_namingBuilder = namingBuilder;
_useCheckpoints = useCheckpoints;
_emitStateUpdated = emitStateUpdated;
_emitPartitionCheckpoints = emitPartitionCheckpoints;
}
protected CoreProjectionCheckpointManager(
ICoreProjection coreProjection, IPublisher publisher, Guid projectionCorrelationId,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name,
PositionTagger positionTagger)
{
if (coreProjection == null) throw new ArgumentNullException("coreProjection");
if (publisher == null) throw new ArgumentNullException("publisher");
if (readDispatcher == null) throw new ArgumentNullException("readDispatcher");
if (writeDispatcher == null) throw new ArgumentNullException("writeDispatcher");
if (projectionConfig == null) throw new ArgumentNullException("projectionConfig");
if (name == null) throw new ArgumentNullException("name");
if (positionTagger == null) throw new ArgumentNullException("positionTagger");
if (name == "") throw new ArgumentException("name");
_lastProcessedEventPosition = new PositionTracker(positionTagger);
_coreProjection = coreProjection;
_publisher = publisher;
_projectionCorrelationId = projectionCorrelationId;
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
_projectionConfig = projectionConfig;
_logger = LogManager.GetLoggerFor<CoreProjectionCheckpointManager>();
_name = name;
_positionTagger = positionTagger;
}
protected CoreProjectionCheckpointManager(
ICoreProjection coreProjection, IPublisher publisher, Guid projectionCorrelationId,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string projectionCheckpointStreamId, string name,
PositionTagger positionTagger)
{
if (coreProjection == null)
{
throw new ArgumentNullException("coreProjection");
}
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (readDispatcher == null)
{
throw new ArgumentNullException("readDispatcher");
}
if (writeDispatcher == null)
{
throw new ArgumentNullException("writeDispatcher");
}
if (projectionConfig == null)
{
throw new ArgumentNullException("projectionConfig");
}
if (projectionCheckpointStreamId == null)
{
throw new ArgumentNullException("projectionCheckpointStreamId");
}
if (projectionCheckpointStreamId == "")
{
throw new ArgumentException("projectionCheckpointStreamId");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (positionTagger == null)
{
throw new ArgumentNullException("positionTagger");
}
if (name == "")
{
throw new ArgumentException("name");
}
_lastProcessedEventPosition = new PositionTracker(positionTagger);
_coreProjection = coreProjection;
_publisher = publisher;
_projectionCorrelationId = projectionCorrelationId;
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
_projectionConfig = projectionConfig;
_logger = LogManager.GetLoggerFor <CoreProjectionCheckpointManager>();
_name = name;
}
public void Setup()
{
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
new FakePublisher(), v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(new FakePublisher()));
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
new FakePublisher(), v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(new FakePublisher()));
}
public void Setup()
{
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
new FakePublisher(), v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(new FakePublisher()));
_writeDispatcher =
new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
new FakePublisher(), v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(new FakePublisher()));
}
public EmittedStream(
string streamId, ProjectionVersion projectionVersion, IPrincipal writeAs, PositionTagger positionTagger,
CheckpointTag zeroPosition, CheckpointTag from,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
IEmittedStreamContainer readyHandler, int maxWriteBatchLength, ILogger logger = null,
bool noCheckpoints = false)
{
if (streamId == null)
{
throw new ArgumentNullException("streamId");
}
if (positionTagger == null)
{
throw new ArgumentNullException("positionTagger");
}
if (zeroPosition == null)
{
throw new ArgumentNullException("zeroPosition");
}
if (@from == null)
{
throw new ArgumentNullException("from");
}
if (readDispatcher == null)
{
throw new ArgumentNullException("readDispatcher");
}
if (writeDispatcher == null)
{
throw new ArgumentNullException("writeDispatcher");
}
if (readyHandler == null)
{
throw new ArgumentNullException("readyHandler");
}
if (streamId == "")
{
throw new ArgumentException("streamId");
}
_streamId = streamId;
_projectionVersion = projectionVersion;
_writeAs = writeAs;
_positionTagger = positionTagger;
_zeroPosition = zeroPosition;
_from = @from;
_lastQueuedEventPosition = null;
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
_readyHandler = readyHandler;
_maxWriteBatchLength = maxWriteBatchLength;
_logger = logger;
_noCheckpoints = noCheckpoints;
}
public ManagedProjection(
IPublisher coreQueue, Guid id, int projectionId, string name, bool enabledToRun, ILogger logger,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
IPublisher inputQueue, IPublisher output, ProjectionStateHandlerFactory projectionStateHandlerFactory,
ITimeProvider timeProvider, ISingletonTimeoutScheduler timeoutScheduler = null, bool isSlave = false,
IPublisher slaveResultsPublisher = null, Guid slaveMasterCorrelationId = default(Guid))
{
if (coreQueue == null)
{
throw new ArgumentNullException("coreQueue");
}
if (id == Guid.Empty)
{
throw new ArgumentException("id");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (output == null)
{
throw new ArgumentNullException("output");
}
if (name == "")
{
throw new ArgumentException("name");
}
_coreQueue = coreQueue;
_id = id;
_projectionId = projectionId;
_name = name;
_enabledToRun = enabledToRun;
_logger = logger;
_writeDispatcher = writeDispatcher;
_readDispatcher = readDispatcher;
_inputQueue = inputQueue;
_output = output;
_projectionStateHandlerFactory = projectionStateHandlerFactory;
_timeProvider = timeProvider;
_timeoutScheduler = timeoutScheduler;
_isSlave = isSlave;
_slaveResultsPublisher = slaveResultsPublisher;
_slaveMasterCorrelationId = slaveMasterCorrelationId;
_getStateDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetState, CoreProjectionManagementMessage.StateReport>(
coreQueue, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
_getResultDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionManagementMessage.ResultReport>(
coreQueue, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
_lastAccessed = _timeProvider.Now;
}
public void setup0()
{
_bus = new InMemoryBus("bus");
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadEventsBackwards, ClientMessage.ReadEventsBackwardsCompleted>(
_bus, e => e.CorrelationId, e => e.CorrelationId);
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, e => e.CorrelationId, e => e.CorrelationId);
}
public MultiStreamCheckpointManager(
ICoreProjection coreProjection, IPublisher publisher, Guid projectionCorrelationId,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name,
PositionTagger positionTagger, string projectionStateUpdatesStreamId)
: base(coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher, projectionConfig, name, positionTagger)
{
_projectionStateUpdatesStreamId = projectionStateUpdatesStreamId;
}
public void setup0()
{
_bus = new InMemoryBus("bus");
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadEventsBackwards, ClientMessage.ReadEventsBackwardsCompleted>(
_bus, e => e.CorrelationId, e => e.CorrelationId);
_writeDispatcher =
new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, e => e.CorrelationId, e => e.CorrelationId);
}
public ProjectionCoreService(IPublisher publisher, IPublisher inputQueue, int eventCacheSize, ICheckpoint writerCheckpoint)
{
_publisher = publisher;
_inputQueue = inputQueue;
_headingEventDistributionPoint = new HeadingEventDistributionPoint(eventCacheSize);
_writerCheckpoint = writerCheckpoint;
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_publisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
_writeDispatcher = new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_publisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
}
public void setup()
{
_readyHandler = new TestCheckpointManagerMessageHandler();
_fakePublisher = new FakePublisher();
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_fakePublisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_fakePublisher));
_writeDispatcher =
new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_fakePublisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_fakePublisher));
}
public MultiStreamCheckpointManager(
ICoreProjection coreProjection, IPublisher publisher, Guid projectionCorrelationId,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name,
PositionTagger positionTagger, string projectionStateUpdatesStreamId)
: base(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher, projectionConfig, name, positionTagger)
{
_projectionStateUpdatesStreamId = projectionStateUpdatesStreamId;
}
public void setup()
{
_readyHandler = new TestCheckpointManagerMessageHandler();
_fakePublisher = new FakePublisher();
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_fakePublisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_fakePublisher));
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_fakePublisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_fakePublisher));
}
public CoreProjection(
string name, Guid projectionCorrelationId, IPublisher publisher,
IProjectionStateHandler projectionStateHandler, ProjectionConfig projectionConfig,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ILogger logger = null)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name == "")
{
throw new ArgumentException("name");
}
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (projectionStateHandler == null)
{
throw new ArgumentNullException("projectionStateHandler");
}
_projectionStateHandler = projectionStateHandler;
_projectionCorrelationId = projectionCorrelationId;
var namingBuilder = new ProjectionNamesBuilder();
_projectionStateHandler.ConfigureSourceProcessingStrategy(namingBuilder);
_name = namingBuilder.ForceProjectionName ?? name;
//TODO: move into name builder
_stateStreamNamePattern = namingBuilder.StateStreamName ?? ProjectionsStreamPrefix + _name + "-{0}" + ProjectionsStateStreamSuffix;
_stateStreamName = namingBuilder.StateStreamName ?? ProjectionsStreamPrefix + _name + ProjectionsStateStreamSuffix;
_projectionConfig = projectionConfig;
_logger = logger;
_publisher = publisher;
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
var builder = new CheckpointStrategy.Builder();
_projectionStateHandler.ConfigureSourceProcessingStrategy(builder);
_checkpointStrategy = builder.Build(_projectionConfig.Mode);
_partitionStateCache = new PartitionStateCache();
_processingQueue = new CoreProjectionQueue(
projectionCorrelationId, publisher, projectionConfig.PendingEventsThreshold, UpdateStatistics);
_checkpointManager = this._checkpointStrategy.CreateCheckpointManager(
this, projectionCorrelationId, this._publisher, this._readDispatcher,
this._writeDispatcher, this._projectionConfig, this._name, _stateStreamName);
GoToState(State.Initial);
}
public DefaultCheckpointManager(
ICoreProjection coreProjection, IPublisher publisher, Guid projectionCorrelationId,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string projectionCheckpointStreamId, string name,
PositionTagger positionTagger)
: base(coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher, projectionConfig, name, positionTagger)
{
if (projectionCheckpointStreamId == null) throw new ArgumentNullException("projectionCheckpointStreamId");
if (projectionCheckpointStreamId == "") throw new ArgumentException("projectionCheckpointStreamId");
_projectionCheckpointStreamId = projectionCheckpointStreamId;
}
private void Handle(
Guid key,
ClientMessage.WriteEventsCompleted message,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writer)
{
lock (_lockObject) {
_writerQueueSet.Finish(key);
_pendingWrites.CompleteRequest(message);
RemovePendingRequest(message.CorrelationId);
WorkQueue(key, writer);
}
}
public DefaultCheckpointManager(
ICoreProjection coreProjection, IPublisher publisher, Guid projectionCorrelationId,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name,
PositionTagger positionTagger, ProjectionNamesBuilder namingBuilder, bool useCheckpoints,
bool emitStateUpdated, bool emitPartitionCheckpoints = false)
: base(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher, projectionConfig,
name, positionTagger, namingBuilder, useCheckpoints, emitStateUpdated, emitPartitionCheckpoints)
{
_projectionCheckpointStreamId = namingBuilder.MakeCheckpointStreamName();
}
public void setup0()
{
_bus = new InMemoryBus("bus");
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, e => e.CorrelationId, e => e.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher =
new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, e => e.CorrelationId, e => e.CorrelationId, new PublishEnvelope(_bus));
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
_consumer = new TestHandler<Message>();
_bus.Subscribe(_consumer);
}
public CoreProjectionDefaultCheckpointManager CreateCheckpointManager(
ICoreProjection coreProjection, Guid projectionCorrelationId, IPublisher publisher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>
requestResponseDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> responseDispatcher,
ProjectionConfig projectionConfig, string name)
{
string projectionCheckpointStreamId = CoreProjection.ProjectionsStreamPrefix + name
+ CoreProjection.ProjectionCheckpointStreamSuffix;
return(new CoreProjectionDefaultCheckpointManager(
coreProjection, publisher, projectionCorrelationId, requestResponseDispatcher, responseDispatcher,
projectionConfig, projectionCheckpointStreamId, name, PositionTagger));
}
public MultiStreamMultiOutputCheckpointManager(
IPublisher publisher, Guid projectionCorrelationId, ProjectionVersion projectionVersion, IPrincipal runAs,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, PositionTagger positionTagger,
ProjectionNamesBuilder namingBuilder, IResultEmitter resultEmitter, bool useCheckpoints,
bool emitPartitionCheckpoints = false)
: base(
publisher, projectionCorrelationId, projectionVersion, runAs, readDispatcher, writeDispatcher,
projectionConfig, name, positionTagger, namingBuilder, resultEmitter, useCheckpoints,
emitPartitionCheckpoints)
{
_positionTagger = positionTagger;
}
public MultiStreamMultiOutputCheckpointManager(
IPublisher publisher, Guid projectionCorrelationId, ProjectionVersion projectionVersion, IPrincipal runAs,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, PositionTagger positionTagger,
ProjectionNamesBuilder namingBuilder, IResultEmitter resultEmitter, bool useCheckpoints,
bool emitPartitionCheckpoints = false)
: base(
publisher, projectionCorrelationId, projectionVersion, runAs, readDispatcher, writeDispatcher,
projectionConfig, name, positionTagger, namingBuilder, resultEmitter, useCheckpoints,
emitPartitionCheckpoints)
{
_positionTagger = positionTagger;
}
public void setup0()
{
_bus = new InMemoryBus("bus");
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, e => e.CorrelationId, e => e.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, e => e.CorrelationId, e => e.CorrelationId, new PublishEnvelope(_bus));
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
_consumer = new WatchingConsumer();
_bus.Subscribe(_consumer);
}
public void QueuePendingWrite(
Guid key,
Guid corrId,
Action <ClientMessage.WriteEventsCompleted> action,
ClientMessage.WriteEvents message,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writer)
{
lock (_lockObject) {
AddPendingRequest(corrId);
_pendingWrites.CaptureCallback(corrId, action);
_writerQueueSet.AddToQueue(key, message);
WorkQueue(key, writer);
}
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestMessageHandler<ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher = new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
_coreProjection = new CoreProjection(
"projection", Guid.NewGuid(), _bus, new FakeProjectionStateHandler(),
new ProjectionConfig(ProjectionMode.AdHoc, 5, 10, 1000, 250, true, true, true), _readDispatcher, _writeDispatcher);
_coreProjection.Start();
}
public ManagedProjection(
Guid id, string name, ILogger logger,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
RequestResponseDispatcher<ClientMessage.ReadEventsBackwards, ClientMessage.ReadEventsBackwardsCompleted>
readDispatcher, IPublisher publisher, ProjectionStateHandlerFactory projectionStateHandlerFactory)
{
if (id == Guid.Empty) throw new ArgumentException("id");
if (name == null) throw new ArgumentNullException("name");
if (name == "") throw new ArgumentException("name");
_id = id;
_name = name;
_logger = logger;
_writeDispatcher = writeDispatcher;
_readDispatcher = readDispatcher;
_publisher = publisher;
_projectionStateHandlerFactory = projectionStateHandlerFactory;
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler <ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher = new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
_coreProjection = new CoreProjection(
"projection", Guid.NewGuid(), _bus, new FakeProjectionStateHandler(),
new ProjectionConfig(ProjectionMode.AdHoc, 5, 10, 1000, 250, true, true, true), _readDispatcher, _writeDispatcher);
_coreProjection.Start();
}
public ProjectionManager(
IPublisher inputQueue, IPublisher publisher, IPublisher[] queues, ITimeProvider timeProvider,
RunProjections runProjections, bool initializeSystemProjections = true)
{
if (inputQueue == null)
{
throw new ArgumentNullException("inputQueue");
}
if (publisher == null)
{
throw new ArgumentNullException("publisher");
}
if (queues == null)
{
throw new ArgumentNullException("queues");
}
if (queues.Length == 0)
{
throw new ArgumentException("At least one queue is required", "queues");
}
_inputQueue = inputQueue;
_publisher = publisher;
_queues = queues;
_timeoutSchedulers = CreateTimeoutSchedulers(queues);
_timeProvider = timeProvider;
_runProjections = runProjections;
_initializeSystemProjections = initializeSystemProjections;
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
publisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
publisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
_projectionStateHandlerFactory = new ProjectionStateHandlerFactory();
_projections = new Dictionary <string, ManagedProjection>();
_projectionsMap = new Dictionary <Guid, string>();
_publishEnvelope = new PublishEnvelope(_inputQueue, crossThread: true);
}
public void setup()
{
_timeProvider = new FakeTimeProvider();
_getStateDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetState, CoreProjectionStatusMessage.StateReport>(
_bus,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_bus));
_getResultDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionStatusMessage.ResultReport>(
_bus,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_bus));
}
public void setup()
{
_timeProvider = new FakeTimeProvider();
_getStateDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetState, CoreProjectionStatusMessage.StateReport>(
_bus,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_bus));
_getResultDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionStatusMessage.ResultReport>(
_bus,
v => v.CorrelationId,
v => v.CorrelationId,
new PublishEnvelope(_bus));
}
public void Setup()
{
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
new FakePublisher(), v => v.CorrelationId, v => v.CorrelationId,
new PublishEnvelope(new FakePublisher()));
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
new FakePublisher(), v => v.CorrelationId, v => v.CorrelationId,
new PublishEnvelope(new FakePublisher()));
_subscriptionDispatcher =
new PublishSubscribeDispatcher
<ReaderSubscriptionManagement.Subscribe,
ReaderSubscriptionManagement.ReaderSubscriptionManagementMessage, EventReaderSubscriptionMessage>
(new FakePublisher(), v => v.SubscriptionId, v => v.SubscriptionId);
}
public ProjectionCheckpoint(
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionVersion projectionVersion, IPrincipal runAs, IProjectionCheckpointManager readyHandler,
CheckpointTag from, PositionTagger positionTagger, CheckpointTag zero, int maxWriteBatchLength,
ILogger logger = null)
{
if (readDispatcher == null)
{
throw new ArgumentNullException("readDispatcher");
}
if (writeDispatcher == null)
{
throw new ArgumentNullException("writeDispatcher");
}
if (readyHandler == null)
{
throw new ArgumentNullException("readyHandler");
}
if (positionTagger == null)
{
throw new ArgumentNullException("positionTagger");
}
if (zero == null)
{
throw new ArgumentNullException("zero");
}
if (from.CommitPosition <= from.PreparePosition)
{
throw new ArgumentException("from");
}
//NOTE: fromCommit can be equal fromPrepare on 0 position. Is it possible anytime later? Ignoring for now.
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
_projectionVersion = projectionVersion;
_runAs = runAs;
_readyHandler = readyHandler;
_positionTagger = positionTagger;
_zero = zero;
_from = _last = from;
_maxWriteBatchLength = maxWriteBatchLength;
_logger = logger;
}
public void Setup()
{
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
new FakePublisher(), v => v.CorrelationId, v => v.CorrelationId,
new PublishEnvelope(new FakePublisher()));
_writeDispatcher =
new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
new FakePublisher(), v => v.CorrelationId, v => v.CorrelationId,
new PublishEnvelope(new FakePublisher()));
_subscriptionDispatcher =
new PublishSubscribeDispatcher
<ReaderSubscriptionManagement.Subscribe,
ReaderSubscriptionManagement.ReaderSubscriptionManagementMessage, EventReaderSubscriptionMessage>
(new FakePublisher(), v => v.SubscriptionId, v => v.SubscriptionId);
}
public void setup()
{
_bus = new InMemoryBus("bus");
_listEventsHandler = new TestHandler<ClientMessage.ReadStreamEventsBackward>();
_bus.Subscribe(_listEventsHandler);
_readDispatcher = new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_writeDispatcher = new RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_bus, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_bus));
_bus.Subscribe(_readDispatcher);
_bus.Subscribe(_writeDispatcher);
IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
_projectionConfig = new ProjectionConfig(5, 10, 1000, 250, true, true, false, false);
_coreProjection = CoreProjection.CreateAndPrepapre(
"projection", Guid.NewGuid(), _bus, projectionStateHandler, _projectionConfig, _readDispatcher,
_writeDispatcher, null);
_coreProjection.Start();
}
private void WorkQueue(
Guid key,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writer)
{
if (_writerQueueSet.IsBusy(key))
{
return;
}
if (!_writerQueueSet.HasPendingWrites(key))
{
return;
}
var write = _writerQueueSet.Dequeue(key);
if (write != null)
{
writer.Publish(write, (msg) => Handle(key, msg, writer));
}
}
public DefaultCheckpointManager(
ICoreProjection coreProjection, IPublisher publisher, Guid projectionCorrelationId,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string projectionCheckpointStreamId, string name,
PositionTagger positionTagger)
: base(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher, projectionConfig, name, positionTagger)
{
if (projectionCheckpointStreamId == null)
{
throw new ArgumentNullException("projectionCheckpointStreamId");
}
if (projectionCheckpointStreamId == "")
{
throw new ArgumentException("projectionCheckpointStreamId");
}
_projectionCheckpointStreamId = projectionCheckpointStreamId;
}
public ProjectionCoreService(
IPublisher inputQueue, IPublisher publisher,
PublishSubscribeDispatcher
<ReaderSubscriptionManagement.Subscribe,
ReaderSubscriptionManagement.ReaderSubscriptionManagementMessage, EventReaderSubscriptionMessage
>
subscriptionDispatcher, ITimeProvider timeProvider)
{
_inputQueue = inputQueue;
_publisher = publisher;
_readDispatcher =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
publisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(inputQueue));
_writeDispatcher =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
_publisher, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
_subscriptionDispatcher = subscriptionDispatcher;
_timeProvider = timeProvider;
}
public void setup0()
{
_envelope = null;
_timeProvider = new FakeTimeProvider();
_bus = new InMemoryBus("bus");
_queue = null;
_ioDispatcher = new IODispatcher(_bus, new PublishEnvelope(GetInputQueue()));
_readDispatcher = _ioDispatcher.BackwardReader;
_writeDispatcher = _ioDispatcher.Writer;
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.BackwardReader);
_bus.Subscribe(_ioDispatcher.ForwardReader);
_bus.Subscribe(_ioDispatcher.Writer);
_bus.Subscribe(_ioDispatcher.StreamDeleter);
_bus.Subscribe(_ioDispatcher);
_consumer = new TestHandler <Message>();
_bus.Subscribe(_consumer);
}
public IODispatcher(IPublisher publisher, IEnvelope envelope)
{
_publisher = publisher;
_inputQueueEnvelope = envelope;
ForwardReader =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsForward, ClientMessage.ReadStreamEventsForwardCompleted>(
publisher, v => v.CorrelationId, v => v.CorrelationId, envelope);
BackwardReader =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
publisher, v => v.CorrelationId, v => v.CorrelationId, envelope);
Writer =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
publisher, v => v.CorrelationId, v => v.CorrelationId, envelope);
StreamDeleter =
new RequestResponseDispatcher <ClientMessage.DeleteStream, ClientMessage.DeleteStreamCompleted>(
publisher, v => v.CorrelationId, v => v.CorrelationId, envelope);
}
public IODispatcher(IPublisher publisher, IEnvelope envelope)
{
_publisher = publisher;
_inputQueueEnvelope = envelope;
ForwardReader =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsForward, ClientMessage.ReadStreamEventsForwardCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
envelope);
BackwardReader =
new RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
envelope);
Writer =
new RequestResponseDispatcher <ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
envelope);
StreamDeleter =
new RequestResponseDispatcher <ClientMessage.DeleteStream, ClientMessage.DeleteStreamCompleted>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
envelope);
Awaker =
new RequestResponseDispatcher <AwakeServiceMessage.SubscribeAwake, IODispatcherDelayedMessage>(
publisher,
v => v.CorrelationId,
v => v.CorrelationId,
envelope,
cancelMessageFactory: requestId => new AwakeServiceMessage.UnsubscribeAwake(requestId));
}
public DefaultCheckpointManager(
IPublisher publisher, Guid projectionCorrelationId, ProjectionVersion projectionVersion, IPrincipal runAs,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, PositionTagger positionTagger,
ProjectionNamesBuilder namingBuilder, IResultEmitter resultEmitter, bool useCheckpoints,
bool emitPartitionCheckpoints = false)
: base(
publisher, projectionCorrelationId, projectionConfig, name, positionTagger, namingBuilder, resultEmitter,
useCheckpoints, emitPartitionCheckpoints)
{
if (readDispatcher == null) throw new ArgumentNullException("readDispatcher");
if (writeDispatcher == null) throw new ArgumentNullException("writeDispatcher");
_projectionVersion = projectionVersion;
_runAs = runAs;
_readDispatcher = readDispatcher;
_writeDispatcher = writeDispatcher;
_positionTagger = positionTagger;
_projectionCheckpointStreamId = namingBuilder.MakeCheckpointStreamName();
_zeroTag = positionTagger.MakeZeroCheckpointTag();
}
public ManagedProjection(
IPublisher coreQueue, Guid id, string name, ILogger logger,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
IPublisher inputQueue, ProjectionStateHandlerFactory projectionStateHandlerFactory)
{
if (id == Guid.Empty) throw new ArgumentException("id");
if (name == null) throw new ArgumentNullException("name");
if (name == "") throw new ArgumentException("name");
_coreQueue = coreQueue;
_id = id;
_name = name;
_logger = logger;
_writeDispatcher = writeDispatcher;
_readDispatcher = readDispatcher;
_inputQueue = inputQueue;
_projectionStateHandlerFactory = projectionStateHandlerFactory;
_getStateDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetState, CoreProjectionManagementMessage.StateReport>(
coreQueue, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
}
public ICoreProjectionCheckpointManager CreateCheckpointManager(
ICoreProjection coreProjection, Guid projectionCorrelationId, IPublisher publisher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, ProjectionNamesBuilder namingBuilder)
{
var emitAny = projectionConfig.EmitEventEnabled;
var emitPartitionCheckpoints = UseCheckpoints && !EmitStateUpdated && (_byCustomPartitions || _byStream);
//NOTE: not emitting one-time/transient projections are always handled by default checkpoint manager
// as they don't depend on stable event order
if (emitAny && _allStreams && _useEventIndexes && _events != null && _events.Count > 1)
{
return new MultiStreamMultiOutputCheckpointManager(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher,
projectionConfig, name, PositionTagger, namingBuilder, UseCheckpoints, EmitStateUpdated,
emitPartitionCheckpoints);
}
else if (emitAny && _streams != null && _streams.Count > 1)
{
return new MultiStreamMultiOutputCheckpointManager(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher,
projectionConfig, name, PositionTagger, namingBuilder, UseCheckpoints, EmitStateUpdated,
emitPartitionCheckpoints);
}
else
{
return new DefaultCheckpointManager(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher,
projectionConfig, name, PositionTagger, namingBuilder, UseCheckpoints, EmitStateUpdated,
emitPartitionCheckpoints);
}
}
public ICoreProjectionCheckpointManager CreateCheckpointManager(
ICoreProjection coreProjection, Guid projectionCorrelationId, IPublisher publisher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>
requestResponseDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> responseDispatcher,
ProjectionConfig projectionConfig, string name, string stateUpdatesStreamId)
{
if (_allStreams && _useEventIndexes && _events != null && _events.Count > 1)
{
string projectionStateUpdatesStreamId = stateUpdatesStreamId;
return new MultiStreamCheckpointManager(
coreProjection, publisher, projectionCorrelationId, requestResponseDispatcher, responseDispatcher,
projectionConfig, name, PositionTagger, projectionStateUpdatesStreamId);
}
else if (_streams != null && _streams.Count > 1)
{
string projectionStateUpdatesStreamId = stateUpdatesStreamId;
return new MultiStreamCheckpointManager(
coreProjection, publisher, projectionCorrelationId, requestResponseDispatcher, responseDispatcher,
projectionConfig, name, PositionTagger, projectionStateUpdatesStreamId);
}
else
{
string projectionCheckpointStreamId = CoreProjection.ProjectionsStreamPrefix + name
+ CoreProjection.ProjectionCheckpointStreamSuffix;
return new DefaultCheckpointManager(
coreProjection, publisher, projectionCorrelationId, requestResponseDispatcher, responseDispatcher,
projectionConfig, projectionCheckpointStreamId, name, PositionTagger);
}
}
public CoreProjectionDefaultCheckpointManager CreateCheckpointManager(
ICoreProjection coreProjection, Guid projectionCorrelationId, IPublisher publisher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted>
requestResponseDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> responseDispatcher,
ProjectionConfig projectionConfig, string name)
{
string projectionCheckpointStreamId = CoreProjection.ProjectionsStreamPrefix + name
+ CoreProjection.ProjectionCheckpointStreamSuffix;
return new CoreProjectionDefaultCheckpointManager(
coreProjection, publisher, projectionCorrelationId, requestResponseDispatcher, responseDispatcher,
projectionConfig, projectionCheckpointStreamId, name, PositionTagger);
}
public ManagedProjection(
Guid workerId,
Guid id,
int projectionId,
string name,
bool enabledToRun,
ILogger logger,
RequestResponseDispatcher<ClientMessage.DeleteStream, ClientMessage.DeleteStreamCompleted> streamDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
IPublisher output,
ITimeProvider timeProvider,
RequestResponseDispatcher<CoreProjectionManagementMessage.GetState, CoreProjectionStatusMessage.StateReport>
getStateDispatcher,
RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionStatusMessage.ResultReport>
getResultDispatcher,
IODispatcher ioDispatcher,
bool isSlave = false,
Guid slaveMasterWorkerId = default(Guid),
Guid slaveMasterCorrelationId = default(Guid))
{
if (id == Guid.Empty) throw new ArgumentException("id");
if (name == null) throw new ArgumentNullException("name");
if (output == null) throw new ArgumentNullException("output");
if (getStateDispatcher == null) throw new ArgumentNullException("getStateDispatcher");
if (getResultDispatcher == null) throw new ArgumentNullException("getResultDispatcher");
if (name == "") throw new ArgumentException("name");
_workerId = workerId;
_id = id;
_projectionId = projectionId;
_name = name;
_enabledToRun = enabledToRun;
_logger = logger ?? LogManager.GetLoggerFor<ManagedProjection>();
_streamDispatcher = streamDispatcher;
_writeDispatcher = writeDispatcher;
_readDispatcher = readDispatcher;
_output = output;
_timeProvider = timeProvider;
_isSlave = isSlave;
_slaveMasterWorkerId = slaveMasterWorkerId;
_slaveMasterCorrelationId = slaveMasterCorrelationId;
_getStateDispatcher = getStateDispatcher;
_getResultDispatcher = getResultDispatcher;
_lastAccessed = _timeProvider.Now;
_ioDispatcher = ioDispatcher;
}
public ICoreProjectionCheckpointManager CreateCheckpointManager(
ICoreProjection coreProjection, Guid projectionCorrelationId, IPublisher publisher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, ProjectionNamesBuilder namingBuilder)
{
var emitPartitionCheckpoints = UseCheckpoints && !EmitStateUpdated && (_byCustomPartitions || _byStream);
if (_allStreams && _useEventIndexes && _events != null && _events.Count > 1)
{
return new MultiStreamMultiOutputCheckpointManager(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher,
projectionConfig, name, PositionTagger, namingBuilder, UseCheckpoints, EmitStateUpdated,
emitPartitionCheckpoints);
}
else if (_streams != null && _streams.Count > 1)
{
return new MultiStreamMultiOutputCheckpointManager(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher,
projectionConfig, name, PositionTagger, namingBuilder, UseCheckpoints, EmitStateUpdated,
emitPartitionCheckpoints);
}
else
{
return new DefaultCheckpointManager(
coreProjection, publisher, projectionCorrelationId, readDispatcher, writeDispatcher,
projectionConfig, name, PositionTagger, namingBuilder, UseCheckpoints, EmitStateUpdated,
emitPartitionCheckpoints);
}
}
public ICoreProjectionCheckpointManager CreateCheckpointManager(
Guid projectionCorrelationId, ProjectionVersion projectionVersion, IPublisher publisher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
ProjectionConfig projectionConfig, string name, ProjectionNamesBuilder namingBuilder)
{
var emitAny = projectionConfig.EmitEventEnabled;
var emitPartitionCheckpoints = UseCheckpoints && (_byCustomPartitions || _byStream);
var resultEmitter = _definesStateTransform
? new ResultEmitter(namingBuilder)
: (IResultEmitter) new NoopResultEmitter();
//NOTE: not emitting one-time/transient projections are always handled by default checkpoint manager
// as they don't depend on stable event order
if (emitAny && !ReaderStrategy.IsReadingOrderRepeatable)
{
return new MultiStreamMultiOutputCheckpointManager(
publisher, projectionCorrelationId, projectionVersion, _runAs, readDispatcher, writeDispatcher,
projectionConfig, name, ReaderStrategy.PositionTagger, namingBuilder, resultEmitter, UseCheckpoints,
emitPartitionCheckpoints);
}
else
{
return new DefaultCheckpointManager(
publisher, projectionCorrelationId, projectionVersion, _runAs, readDispatcher, writeDispatcher,
projectionConfig, name, ReaderStrategy.PositionTagger, namingBuilder, resultEmitter, UseCheckpoints,
emitPartitionCheckpoints);
}
}
public ManagedProjection(
IPublisher coreQueue, Guid id, int projectionId, string name, bool enabledToRun, ILogger logger,
RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
RequestResponseDispatcher
<ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
IPublisher inputQueue, IPublisher output, ProjectionStateHandlerFactory projectionStateHandlerFactory,
ITimeProvider timeProvider, ISingletonTimeoutScheduler timeoutScheduler = null, bool isSlave = false,
IPublisher slaveResultsPublisher = null, Guid slaveMasterCorrelationId = default(Guid))
{
if (coreQueue == null) throw new ArgumentNullException("coreQueue");
if (id == Guid.Empty) throw new ArgumentException("id");
if (name == null) throw new ArgumentNullException("name");
if (output == null) throw new ArgumentNullException("output");
if (name == "") throw new ArgumentException("name");
_coreQueue = coreQueue;
_id = id;
_projectionId = projectionId;
_name = name;
_enabledToRun = enabledToRun;
_logger = logger;
_writeDispatcher = writeDispatcher;
_readDispatcher = readDispatcher;
_inputQueue = inputQueue;
_output = output;
_projectionStateHandlerFactory = projectionStateHandlerFactory;
_timeProvider = timeProvider;
_timeoutScheduler = timeoutScheduler;
_isSlave = isSlave;
_slaveResultsPublisher = slaveResultsPublisher;
_slaveMasterCorrelationId = slaveMasterCorrelationId;
_getStateDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetState, CoreProjectionManagementMessage.StateReport>(
coreQueue, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
_getResultDispatcher =
new RequestResponseDispatcher
<CoreProjectionManagementMessage.GetResult, CoreProjectionManagementMessage.ResultReport>(
coreQueue, v => v.CorrelationId, v => v.CorrelationId, new PublishEnvelope(_inputQueue));
_lastAccessed = _timeProvider.Now;
}
