private void ReplaceMessageToQueue(Channel channel, Message message)
{
Node node;
var isSuccess = AllConstants.RandomGenerator.NextDouble() >= channel.ErrorChance;
if (channel.IsBusy && channel.MessageOwnerId != message.ParentId)
{
isSuccess = false;
}
if (message.LastTransferNodeId == channel.FirstNodeId && !isSuccess ||
message.LastTransferNodeId != channel.FirstNodeId && isSuccess)
{
node = _network.GetNodeById(channel.FirstNodeId);
}
else
{
node = _network.GetNodeById(channel.SecondNodeId);
}
if (!isSuccess)
{
message.SendAttempts++;
}
else
{
MakeChannelFree(message);
}
var messageQueueHandler = node.MessageQueueHandlers
.First(m => m.ChannelId == channel.Id);
messageQueueHandler.AddMessageInStart(message);
}
public void AddInQueue(Message[] messages, uint nodeId)
{
foreach (var message in messages)
{
Network.AddInQueue(message, nodeId);
}
var node = Network.GetNodeById(nodeId);
node.NetworkMatrix = MessageRouter.CountPriceMatrix(nodeId, nodeId, node.NetworkMatrix);
}
public void GetNodeByIdShouldReturnCorrectNode()
{
// Arrange
_network.AddNode(_node1);
// Act
var result = _network.GetNodeById(_node1.Id);
// Assert
Assert.IsTrue(result.LinkedNodesId.All(i => _node1.LinkedNodesId.Any(i1 => i1 == i)));
Assert.That(result.MessageQueueHandlers.Count, Is.EqualTo(_node1.MessageQueueHandlers.Count));
}
private void ConnectCentralMachineToOtherNodes(IEnumerable <uint> nodesIdConnectedToCentralMachine, uint centralMachineId)
{
foreach (var nodeId in nodesIdConnectedToCentralMachine)
{
var price = ChannelParamsGenerator.GetRandomPrice();
var capacity = ChannelParamsGenerator.GetCapactity(price) / 3;
var channel = new Channel
{
Id = Guid.NewGuid(),
FirstNodeId = centralMachineId,
SecondNodeId = nodeId,
ConnectionType = ConnectionType.Duplex,
ChannelType = ChannelType.Satellite,
ErrorChance = AllConstants.RandomGenerator.NextDouble(),
Price = price,
IsBusy = false,
Capacity = capacity
};
var metropolitanNode = _network.GetNodeById(nodeId);
metropolitanNode.NodeType = NodeType.MainMetropolitanMachine;
_network.AddChannel(channel);
}
}
public IEnumerable <Message> GetAllMessages(uint?nodeId = null,
MessageFiltrationMode messageFiltrationMode = MessageFiltrationMode.AllMessages)
{
IEnumerable <Message> result = new List <Message>();
if (nodeId != null && _network.GetNodeById(nodeId.Value) == null)
{
throw new NodeException("Node isn't exist");
}
if ((messageFiltrationMode & MessageFiltrationMode.CanceledMessagesOnly) != 0)
{
result = result.Union(GetCanceledMessages(nodeId));
}
if (nodeId == null && (messageFiltrationMode & MessageFiltrationMode.ChannelMessagesOnly) != 0)
{
result = result.Union(GetMessagesInChannels());
}
if ((messageFiltrationMode & MessageFiltrationMode.QueueMessagesOnly) != 0)
{
result = result.Union(GetQueueMessages(nodeId));
}
if ((messageFiltrationMode & MessageFiltrationMode.ReceivedMessagesOnly) != 0)
{
result = result.Union(GetReceivedMessages(nodeId));
}
return(result.ToArray());
}
public Channel[] GetRoute(uint senderId, uint receiverId)
{
if (senderId == receiverId)
{
return(new Channel[0]);
}
var sender = Network.GetNodeById(senderId);
var networkMatrix = sender.NetworkMatrix;
if (networkMatrix == null ||
double.IsInfinity(networkMatrix.NodeIdWithCurrentPrice[receiverId]))
{
return(null);
}
var route = BuildRoute(networkMatrix, senderId, receiverId);
return(route.ToArray());
}
public virtual void UpdateComponents()
{
var elementsToRemove = new List <Grid>();
foreach (var createdGrid in CreatedGrids)
{
var nodeDto = (NodeDto)createdGrid.Tag;
var node = Network.GetNodeById(nodeDto.Id);
if (node == null)
{
elementsToRemove.Add(createdGrid);
}
else
{
createdGrid.Tag = Mapper.Map <Node, NodeDto>(node);
nodeDto = (NodeDto)createdGrid.Tag;
createdGrid.Background = GetBackground(nodeDto);
}
}
RemoveRange(elementsToRemove);
}
public void HandleMessage(Message message)
{
var receiver = _network.GetNodeById(message.ReceiverId);
receiver.ReceivedMessages.Add(message);
message.IsReceived = true;
switch (message.MessageType)
{
case MessageType.General:
{
HandleGeneralMessage(message);
break;
}
case MessageType.MatrixUpdateMessage:
{
HandleUpdateTableMessage(message);
break;
}
case MessageType.SendingRequest:
{
HandleSendingRequest(message);
break;
}
case MessageType.PositiveSendingResponse:
{
HandlePositiveSendingResponse(message);
break;
}
case MessageType.NegativeSendingResponse:
{
HandleNegativeSendingResponse(message);
break;
}
case MessageType.PositiveReceiveResponse:
{
HandlePositiveReceiveResponce(message);
break;
}
default:
{
throw new ArgumentOutOfRangeException();
}
}
message.Route = message.Route
.Skip(1)
.ToArray();
}
private void SearchConnectedNodes(ICollection <Node> currentNetwork, Node node)
{
foreach (var linkedNodeId in node.LinkedNodesId)
{
var channel = _network.GetChannel(node.Id, linkedNodeId);
if (currentNetwork.Any(n => n.Id == linkedNodeId) || channel.ChannelType == ChannelType.Satellite)
{
continue;
}
var linkedNode = _network.GetNodeById(linkedNodeId);
currentNetwork.Add(linkedNode);
SearchConnectedNodes(currentNetwork, linkedNode);
}
}
