protected MessageProcessor(
DispatcherQueueSetting setting,
IReliableLog <TMessage> inputMessageQueue,
IReliableLog <OutputMessage> outputMessageQueue,
IMessageFilteringEngine <TMessage> filteringEngine,
IResultReporter resultReporter)
: base(nameof(MessageProcessor <TMessage>))
{
this.setting = setting;
this.inputMessageQueue = inputMessageQueue;
this.outputMessageQueue = outputMessageQueue;
this.filteringEngine = filteringEngine;
this.resultReporter = resultReporter;
this.processorComponents = new ComponentManager(this.setting.Name, "MessageProcessorContainer");
this.processorComponents.Faulted += (s, e) => this.Fault(e.Exception);
this.messageDispatcher = MessageDispatcher.Create(
this.setting,
this.outputMessageQueue,
this.resultReporter);
this.processorComponents.Add(this.messageDispatcher);
this.messagePump = MessagePump <TMessage> .Create(
this.setting,
this.inputMessageQueue,
this.filteringEngine,
this.messageDispatcher);
this.processorComponents.Add(this.messagePump);
}
protected MessageDispatcher(
DispatcherQueueSetting setting,
IReliableLog <OutputMessage> outputMessageQueue,
IResultReporter resultReporter)
: base(nameof(MessageDispatcher))
{
this.setting = setting;
this.outputMessageQueue = outputMessageQueue;
this.resultReporter = resultReporter;
this.pushWorkers = new List <IPushWorker>();
this.random = new ThreadSafeRandom();
this.dispatcherComponents = new ComponentManager(this.setting.Name, "MessageDispatcherContainer");
this.dispatcherComponents.Faulted += (s, e) => this.Fault(e.Exception);
for (var i = 0; i < this.setting.PushWorkerCount; ++i)
{
var pushWorker = PushWorker.Create(
this.setting,
this.outputMessageQueue,
this,
this.resultReporter);
this.pushWorkers.Add(pushWorker);
this.dispatcherComponents.Add(pushWorker);
}
}
public RowTransformer(
IColumnMapBuilder columnMapBuilder,
IRowTransformerFactory <TRowTransformer> factory,
ITransformationRunner <TRowTransformer> transformerRunner,
IResultReporter reporter)
: base(columnMapBuilder, factory, transformerRunner, reporter)
{
}
public RowFilterer(
IColumnMapBuilder columnMapBuilder,
IDocumentTransformerFactory <Filtering.IRowMatchEvaluator> factory,
ITransformationRunner <Filtering.IRowMatchEvaluator> transformerRunner,
IResultReporter reporter)
: base(columnMapBuilder, factory, transformerRunner, reporter)
{
}
public static InputMessageFilteringEngine Create(
DispatcherQueueSetting dispatcherQueueSetting,
IResultReporter resultReporter)
{
return(new InputMessageFilteringEngine(
dispatcherQueueSetting,
resultReporter));
}
private TurtleGame GetTurtleGame(IResultReporter resultReporter)
{
var gameSettings = new GameSettingsBuilder().Build();
IBoardController boardController = new BoardController(gameSettings);
ISequencesRetriever sequencesRetriever = new InMemorySequenceRetriever();
ISequenceController sequenceController = new SequenceController(sequencesRetriever);
return(new TurtleGame(boardController, sequenceController, resultReporter));
}
public void Constructor_GivenNullResultReporter_ShouldThrowError()
{
IBoardController boardController = new Mock <IBoardController>().Object;
ISequenceController sequenceController = new Mock <ISequenceController>().Object;
IResultReporter resultReporter = null;
var exception = Record.Exception(() => new TurtleGame(boardController, sequenceController, resultReporter));
Assert.IsType <ArgumentNullException>(exception);
}
public static IMessageDispatcher Create(
DispatcherQueueSetting setting,
IReliableLog <OutputMessage> outputMessageQueue,
IResultReporter resultReporter)
{
return(new MessageDispatcher(
setting,
outputMessageQueue,
resultReporter));
}
public static OutputMessageFilteringEngine Create(
DispatcherQueueSetting dispatcherQueueSetting,
IMessageFilteringEngine <InputMessage> inputMessageFilteringEngine,
IResultReporter resultReporter)
{
return(new OutputMessageFilteringEngine(
dispatcherQueueSetting,
inputMessageFilteringEngine,
resultReporter));
}
protected OutputMessageFilteringEngine(
DispatcherQueueSetting setting,
IMessageFilteringEngine <InputMessage> inputMessageFilteringEngine,
IResultReporter resultReporter)
: base(nameof(OutputMessageFilteringEngine))
{
this.setting = setting;
this.inputMessageFilteringEngine = inputMessageFilteringEngine;
this.resultReporter = resultReporter;
}
public DocumentTransformer(
IColumnMapBuilder columnMapBuilder,
IDocumentTransformerFactory <TTransformer> factory,
ITransformationRunner <TTransformer> transformerRunner,
IResultReporter reporter)
{
this.columnMapBuilder = columnMapBuilder;
this.factory = factory;
this.transformerRunner = transformerRunner;
this.reporter = reporter;
}
public MessageDispatcher(StatefulServiceContext context)
: base(context)
{
this.components = new ComponentManager(nameof(MessageDispatcher), "RootContainer");
var partitionSetting = DispatcherPartitionSetting.Create();
var resultReporter = ResultReporter.Create();
var inputMessageFilteringEngine = InputMessageFilteringEngine.Create(partitionSetting.InstantQueueSetting, resultReporter);
// Delayed Queue
IReliableLog <OutputMessage> nextOutputReliableLog = null;
for (var i = partitionSetting.DelayedQueueSettings.Count - 1; i >= 0; i--)
{
var setting = partitionSetting.DelayedQueueSettings[i];
var outputMessageFilteringEngine = OutputMessageFilteringEngine.Create(setting, inputMessageFilteringEngine, resultReporter);
var outputReliableLog = ReliableLog <OutputMessage> .Create(setting, this.StateManager);
outputReliableLog = new DelayedReliableLog(outputReliableLog);
var outputMessageProcessor = MessageProcessor <OutputMessage> .Create(
setting,
outputReliableLog,
nextOutputReliableLog ?? outputReliableLog,
outputMessageFilteringEngine,
resultReporter);
this.components.Add(outputMessageFilteringEngine);
this.components.Add(outputReliableLog);
this.components.Add(outputMessageProcessor);
nextOutputReliableLog = outputReliableLog;
}
// Instant Queue
var inputReliableLog = ReliableLog <InputMessage> .Create(partitionSetting.InstantQueueSetting, this.StateManager);
var inputMessageProcessor = MessageProcessor <InputMessage> .Create(
partitionSetting.InstantQueueSetting,
inputReliableLog,
nextOutputReliableLog,
inputMessageFilteringEngine,
resultReporter);
this.components.Add(inputMessageFilteringEngine);
this.components.Add(inputReliableLog);
this.components.Add(inputMessageProcessor);
this.components.Add(resultReporter);
this.inputReliableLog = inputReliableLog;
this.resultReporter = resultReporter;
MessageDispatcher.AppName = context.CodePackageActivationContext.ApplicationTypeName;
}
protected InputMessageFilteringEngine(
DispatcherQueueSetting setting,
IResultReporter resultReporter)
: base(nameof(InputMessageFilteringEngine))
{
this.setting = setting;
this.resultReporter = resultReporter;
this.proxyFactory = new ServiceProxyFactory((c) =>
{
return(new FabricTransportServiceRemotingClientFactory(
serializationProvider: new ServiceRemotingJsonSerializationProvider()));
});
}
protected PushWorker(
DispatcherQueueSetting setting,
IReliableLog <OutputMessage> outputMessageQueue,
IMessageDispatcher messageDispatcher,
IResultReporter resultReporter)
: base(nameof(PushWorker))
{
this.setting = setting;
this.outputMessageQueue = outputMessageQueue;
this.messageDispatcher = messageDispatcher;
this.pushTaskAvailableSignal = new AsyncSignal(SignalWaitTime);
this.messageQueue = new ConcurrentQueue <PushTaskInfo>();
this.resultReporter = resultReporter;
}
public static IMessageProcessor <TMessage> Create(
DispatcherQueueSetting setting,
IReliableLog <TMessage> inputMessageQueue,
IReliableLog <OutputMessage> outputMessageQueue,
IMessageFilteringEngine <TMessage> filteringEngine,
IResultReporter resultReporter)
{
return(new MessageProcessor <TMessage>(
setting,
inputMessageQueue,
outputMessageQueue,
filteringEngine,
resultReporter));
}
public TurtleGame(IBoardController boardController, ISequenceController sequenceController, IResultReporter resultReporter)
{
_boardController = boardController ?? throw new System.ArgumentNullException(nameof(boardController));
_sequenceController = sequenceController ?? throw new System.ArgumentNullException(nameof(sequenceController));
_resultReporter = resultReporter ?? throw new System.ArgumentNullException(nameof(resultReporter));
}
