public SolutionsMessageHandler(IProblemManager manager, IMessagesSender sender, IBackupServerManager backups,
IBackupSender backupSender, ICsDataStore nodeStore)
: base(manager, sender, backupSender)
{
this.backups = backups;
this.nodeStore = nodeStore;
}
public RegisterMessageHandler(IMessagesSender messagesSender, CommunicationsServerConfiguration config,
IClientIdGenerator generator, IMediator mediator, IBackupSender sender)
{
this.messagesSender = messagesSender;
this.config = config;
this.generator = generator;
this.mediator = mediator;
this.sender = sender;
}
public StatusMessageHandler(IMessagesSender messagesSender, IMediator mediator,
IBackupServerManager backupServers, IProblemDispatcher problemDispatcher, IBackupSender backupSender)
{
this.messagesSender = messagesSender;
this.mediator = mediator;
this.backupServers = backupServers;
this.problemDispatcher = problemDispatcher;
this.backupSender = backupSender;
}
public StatusMessageHandlerTests()
{
mediator = A.Fake <IMediator>();
sender = A.Fake <IMessagesSender>();
backupServers = A.Fake <IBackupServerManager>();
client = A.Fake <ITcpClient>();
dispatcher = A.Fake <IProblemDispatcher>();
backupSender = A.Fake <IBackupSender>();
A.CallTo(() => client.GetStream()).Returns(A.Fake <INetworkStream>());
A.CallTo(() => backupServers.BackupServers).Returns(SampleServers);
A.CallTo(() => dispatcher.GetWorkForNode(0)).WithAnyArguments().Returns(null);
handler = new StatusMessageHandler(sender, mediator, backupServers, dispatcher, backupSender);
}
public RegisterMessageHandlerTests()
{
sender = A.Fake <IMessagesSender>();
config = new CommunicationsServerConfiguration {
CommunicationsTimeout = Timeout
};
idGenerator = A.Fake <IClientIdGenerator>();
backupManager = A.Fake <IBackupServerManager>();
mediator = A.Fake <IMediator>();
client = A.Fake <ITcpClient>();
backupSender = A.Fake <IBackupSender>();
A.CallTo(() => backupManager.BackupServers).Returns(A.CollectionOfFake <BackupNodeInfo>(0).ToArray());
A.CallTo(() => client.GetStream()).Returns(A.Fake <INetworkStream>());
A.CallTo(() => client.RemoteEndpoint).Returns(Endpoint);
message = new RegisterMessage {
Type = Constants.NodeTypes.ComputationalNode
};
A.CallTo(() => idGenerator.Next()).Returns(NodeId);
handler = new RegisterMessageHandler(sender, config, idGenerator, mediator, backupSender);
}
public NotifyBackupOfDeadNode(IBackupSender sender)
{
this.sender = sender;
}
public SolveRequestHandler(IProblemManager manager, IMessagesSender sender, IBackupSender backupSender)
: base(manager, sender, backupSender)
{
}
public BaseProblemHandler(IProblemManager manager, IMessagesSender sender, IBackupSender backupSender)
{
this.manager = manager;
this.sender = sender;
this.backupSender = backupSender;
}
public BackupMessageResender(IMediator mediator, IBackupSender backupSender)
{
this.mediator = mediator;
this.backupSender = backupSender;
}
