private void CreateMessage_OnClick(object sender, RoutedEventArgs e)
{
Action action = () =>
{
var senderId = uint.Parse(SenderId.Text);
var receiverId = uint.Parse(ReceiverId.Text);
var size = int.Parse(Size.Text);
var messageInitializer = new MessageInitializer
{
MessageType = MessageType.General,
ReceiverId = receiverId,
SenderId = senderId,
Data = null,
Size = size
};
OnMessageCreateEvent(messageInitializer);
MessageBox.Show("Message Created", "Ok", MessageBoxButton.OK, MessageBoxImage.Information,
MessageBoxResult.OK,
MessageBoxOptions.None);
};
_exceptionCatcher.Decorate(action, ExceptionMessageBox.Show);
}
private void CreateInitializeMessages(Node centralMachine, Dictionary <uint, NetworkMatrix> networkMatrises)
{
foreach (var linkedNodeId in centralMachine.LinkedNodesId)
{
var linkedNode = Network.GetNodeById(linkedNodeId);
if (!linkedNode.IsActive)
{
continue;
}
var messageInitializer = new MessageInitializer
{
Size = AllConstants.InitializeMessageSize,
MessageType = MessageType.MatrixUpdateMessage,
ReceiverId = linkedNodeId,
SenderId = centralMachine.Id,
Data = networkMatrises
};
var messages = CreateMessages(messageInitializer);
if (messages != null)
{
foreach (var message in messages)
{
var messageQueue = centralMachine.MessageQueueHandlers
.First(m => m.ChannelId == message.Route[0].Id);
messageQueue.AddMessageInStart(message);
}
}
}
}
private Message CreateMessage(MessageInitializer messageInitializer, Channel[] route)
{
var message = new Message
{
MessageType = messageInitializer.MessageType,
ReceiverId = messageInitializer.ReceiverId,
LastTransferNodeId = messageInitializer.SenderId,
Route = route,
SenderId = messageInitializer.SenderId,
Data = messageInitializer.Data,
DataSize = GetDataSize(messageInitializer),
ServiceSize = GetServiceSize(messageInitializer),
ParentId = Guid.NewGuid(),
SendAttempts = 0
};
if (message.MessageType == MessageType.General)
{
var positiveReceiveResponse = CreatePositiveReceiveResponse(messageInitializer, message);
message.Data = new[] { positiveReceiveResponse };
}
return(message);
}
private void InitializeLinkedNodes(Node node, IDictionary <uint, NetworkMatrix> networkMatrises)
{
foreach (var linkedNodeId in node.LinkedNodesId)
{
var linkedNode = _network.GetNodeById(linkedNodeId);
if (!linkedNode.IsActive || linkedNode.IsTableUpdated)
{
continue;
}
var messageInitializer = new MessageInitializer
{
Data = networkMatrises,
MessageType = MessageType.MatrixUpdateMessage,
ReceiverId = linkedNodeId,
SenderId = node.Id,
Size = AllConstants.InitializeMessageSize
};
var initializeMessage = _generalMessageCreator.CreateMessages(messageInitializer);
if (initializeMessage != null)
{
_generalMessageCreator.AddInQueue(initializeMessage
.Where(m => m.Route.Length == 1)
.ToArray(), node.Id);
}
}
}
private int GetDataSize(MessageInitializer messageInitializer)
{
if (messageInitializer.MessageType == MessageType.General)
{
return(messageInitializer.Size);
}
return(0);
}
public override Message[] CreateMessages(MessageInitializer messageInitializer)
{
var undividedMessages = base.CreateMessages(messageInitializer);
if (undividedMessages != null)
{
return(DivideIntoPackages(undividedMessages.First()));
}
return(null);
}
protected override MessageInitializer CreateMessageInitializer(uint senderId, uint receiverId)
{
var messageInitializer = new MessageInitializer
{
ReceiverId = receiverId,
MessageType = MessageType.General,
SenderId = senderId,
Data = null,
Size = _messageSize
};
return(messageInitializer);
}
private int GetServiceSize(MessageInitializer messageInitializer)
{
if (messageInitializer.MessageType == MessageType.MatrixUpdateMessage ||
messageInitializer.MessageType == MessageType.NegativeSendingResponse ||
messageInitializer.MessageType == MessageType.PositiveSendingResponse ||
messageInitializer.MessageType == MessageType.SendingRequest ||
messageInitializer.MessageType == MessageType.PositiveReceiveResponse)
{
return(messageInitializer.Size + AllConstants.ServicePartSize);
}
return(AllConstants.ServicePartSize);
}
private void MessageCreate(MessageInitializer messageInitializer)
{
var messages = _messageCreator?.CreateMessages(messageInitializer);
if (messages != null)
{
var senderId = messageInitializer.SenderId;
_messageCreator.AddInQueue(messages, senderId);
}
else
{
throw new MessageException("Message Cannot Be Created");
}
}
public virtual Message[] CreateMessages(MessageInitializer messageInitializer)
{
var route = MessageRouter.GetRoute(messageInitializer.SenderId,
messageInitializer.ReceiverId);
if (route == null)
{
return(null);
}
var message = CreateMessage(messageInitializer, route);
return(new[] { message });
}
protected virtual MessageInitializer CreateMessageInitializer(uint senderId, uint receiverId)
{
var messageSize = AllConstants.RandomGenerator.Next(AllConstants.MaxMessageSize) + 1;
var messageInitializer = new MessageInitializer
{
ReceiverId = receiverId,
MessageType = MessageType.General,
SenderId = senderId,
Data = null,
Size = messageSize
};
return(messageInitializer);
}
public override Message[] CreateMessages(MessageInitializer messageInitializer)
{
var messages = base.CreateMessages(messageInitializer);
if (messages != null)
{
foreach (var message in messages)
{
message.Route = messages[0].Route.ToArray();
}
var request = CreateRequestMessage(messages);
return(request);
}
return(null);
}
private void HandleSendingRequest(Message request)
{
var responseInitializer = new MessageInitializer
{
ReceiverId = request.SenderId,
SenderId = request.ReceiverId,
MessageType = MessageType.PositiveSendingResponse,
Data = request.Data
};
var responses = _positiveResponseMessageCreator.CreateMessages(responseInitializer);
foreach (var response in responses)
{
response.ParentId = request.ParentId;
}
_positiveResponseMessageCreator.AddInQueue(responses, request.ReceiverId);
}
private void HandleNegativeSendingResponse(Message response)
{
var requests = (Message[])response.Data;
var request = requests.First();
var oldMessages = (Message[])request.Data;
var firstMessage = oldMessages.First();
var sumSize = oldMessages.Sum(oldMessage => oldMessage.Size)
- oldMessages.Length * AllConstants.ServicePartSize;
var messageInitializer = new MessageInitializer
{
MessageType = firstMessage.MessageType,
ReceiverId = firstMessage.ReceiverId,
SenderId = firstMessage.SenderId,
Size = sumSize,
Data = firstMessage.Data
};
var messages = _generalMessageCreator.CreateMessages(messageInitializer);
if (messages != null)
{
UpdateInnerMessagesIds(messages, firstMessage.ParentId);
var receiver = _network.GetNodeById(response.ReceiverId);
request.IsCanceled = true;
receiver.CanceledMessages.Add(request);
_generalMessageCreator.AddInQueue(messages, firstMessage.SenderId);
}
else
{
request.Route = firstMessage.Route.ToArray();
request.LastTransferNodeId = request.SenderId;
_generalMessageCreator.AddInQueue(requests, firstMessage.SenderId);
}
_generalMessageCreator.RemoveFromQueue(new[] { response }, response.ReceiverId);
}
private static Message CreatePositiveReceiveResponse(MessageInitializer messageInitializer, Message message)
{
var reversedRoute = message.Route
.ToArray()
.Reverse();
var positiveReceiveResponse = new Message
{
MessageType = MessageType.PositiveReceiveResponse,
Data = null,
ReceiverId = messageInitializer.SenderId,
SenderId = messageInitializer.ReceiverId,
Route = reversedRoute.ToArray(),
ParentId = message.ParentId,
ServiceSize = AllConstants.ReceiveResponseMessageSize,
LastTransferNodeId = messageInitializer.ReceiverId,
SendAttempts = 0,
};
return(positiveReceiveResponse);
}
private Message CreateResponse(MessageInitializer messageInitializer)
{
ThrowExceptionIfMessageTypeIsNotCorrectResponse(messageInitializer.MessageType);
var data = (Message[])messageInitializer.Data;
IEnumerable <Channel> route = data.First().Route;
route = route.Reverse();
return(new Message
{
Data = messageInitializer.Data,
LastTransferNodeId = messageInitializer.SenderId,
MessageType = messageInitializer.MessageType,
ParentId = Guid.NewGuid(),
ReceiverId = messageInitializer.ReceiverId,
SendAttempts = 0,
SenderId = messageInitializer.SenderId,
DataSize = 0,
ServiceSize = AllConstants.InitializeMessageSize,
Route = route.ToArray(),
});
}
protected virtual void OnMessageCreateEvent(MessageInitializer messageinitializer)
{
MessageCreateEvent?.Invoke(messageinitializer);
}
public override Message[] CreateMessages(MessageInitializer messageInitializer)
{
var result = new[] { CreateResponse(messageInitializer) };
return(result);
}
public TcpServer(IServerFeedbackProvider feedbackProvider)
{
_formatter = new CustomBinaryFormatter();
MessageInitializer.RegisterMessagesWithSerializer(_formatter);
_feedbackProvider = feedbackProvider;
}
public NetClient(IClientFeedbackProvider feedbackProvider)
{
IsSending = false;
MessageInitializer.RegisterMessagesWithSerializer(_formatter);
_feedbackProvider = feedbackProvider;
}
public void Setup()
{
_networkMock = new Mock <INetworkHandler>();
_messageRouterMock = new Mock <IMessageRouter>();
_messageCreator = new PositiveResponseCreator(_networkMock.Object, _messageRouterMock.Object);
_channels = new[]
{
new Channel
{
Id = Guid.NewGuid(),
ConnectionType = ConnectionType.Duplex,
ChannelType = ChannelType.Ground,
FirstNodeId = 0,
ErrorChance = 0.5,
SecondNodeId = 1,
Price = 10
},
new Channel
{
Id = Guid.NewGuid(),
ConnectionType = ConnectionType.Duplex,
ChannelType = ChannelType.Ground,
FirstNodeId = 0,
ErrorChance = 0.5,
SecondNodeId = 2,
Price = 20
},
new Channel
{
Id = Guid.NewGuid(),
ConnectionType = ConnectionType.Duplex,
ChannelType = ChannelType.Ground,
FirstNodeId = 1,
ErrorChance = 0.5,
SecondNodeId = 3,
Price = 100
},
new Channel
{
Id = Guid.NewGuid(),
ConnectionType = ConnectionType.Duplex,
ChannelType = ChannelType.Ground,
FirstNodeId = 2,
ErrorChance = 0.5,
SecondNodeId = 3,
Price = 1
},
};
_nodes = new[]
{
new Node
{
Id = 0,
LinkedNodesId = new SortedSet <uint>(new uint[] { 1, 2 }),
MessageQueueHandlers = new List <MessageQueueHandler>
{
new MessageQueueHandler(_channels[0].Id),
new MessageQueueHandler(_channels[1].Id)
},
IsActive = true
},
new Node
{
Id = 1,
LinkedNodesId = new SortedSet <uint>(new uint[] { 0, 3 }),
MessageQueueHandlers = new List <MessageQueueHandler>
{
new MessageQueueHandler(_channels[0].Id),
new MessageQueueHandler(_channels[2].Id)
},
IsActive = true
},
new Node
{
Id = 2,
LinkedNodesId = new SortedSet <uint>(new uint[] { 0, 3 }),
MessageQueueHandlers = new List <MessageQueueHandler>
{
new MessageQueueHandler(_channels[1].Id),
new MessageQueueHandler(_channels[3].Id)
},
IsActive = true
},
new Node
{
Id = 3,
LinkedNodesId = new SortedSet <uint>(new uint[] { 1, 2 }),
MessageQueueHandlers = new List <MessageQueueHandler>
{
new MessageQueueHandler(_channels[2].Id),
new MessageQueueHandler(_channels[3].Id)
},
IsActive = true
}
};
_networkMock.Setup(n => n.Nodes)
.Returns(_nodes);
_networkMock.Setup(n => n.Channels)
.Returns(_channels);
_networkMock.Setup(n => n.GetNodeById(It.IsAny <uint>()))
.Returns((uint nodeId) => _nodes.FirstOrDefault(n => n.Id == nodeId));
_networkMock.Setup(n => n.GetChannel(It.IsAny <uint>(), It.IsAny <uint>()))
.Returns((uint firstNodeId, uint secondNodeId) =>
{
return(_channels.FirstOrDefault(c => c.FirstNodeId == firstNodeId && c.SecondNodeId == secondNodeId
||
c.FirstNodeId == secondNodeId && c.SecondNodeId == firstNodeId));
}
);
_messageRouterMock.Setup(m => m.GetRoute(It.IsAny <uint>(), It.IsAny <uint>()))
.Returns((uint senderId, uint receiverId) =>
{
var sender = _nodes.First(n => n.Id == senderId);
return(new[]
{
_channels.First(c => c.Id == sender.MessageQueueHandlers.First().ChannelId)
});
});
_messageInitializer = new MessageInitializer
{
MessageType = MessageType.PositiveSendingResponse,
ReceiverId = 2,
SenderId = 0,
Data = new[]
{
new Message {
Route = new[] { _channels.First() }
},
new Message {
Route = new[] { _channels.Skip(1).First() }
}
},
Size = AllConstants.MaxMessageSize
};
}
